my_core_javaday8

Static:
修饰符没有前后顺序
static 修饰符
用在什么地方。
修饰成员变量： private static int age;
修饰成员方法: public static void show(){}
修饰代码块 : static{}
匿名代码块/非静态代码块：在创建对象时就会执行
每创建一个对象，就执行一次
静态代码块:在类加载的时候会调用一次,且只调用一次。
用途:一般用来给类中的【静态属性赋值】。

内存机制：
静态资源都是[属于类]，
在内存中存放于静态[方法区]，
类加载(eg：java Hello jvm就会加载 Hello 类)的时候就会创建静态资源的内存空间。
所以，静态资源[一个类只有一份]，
那么这个类的任何实例对象去操作该类的静态资源，实质上是操作同一个资源。
–>【多个实例操作静态资源，
是操作同一个资源】。
静态方法不存在重写
父类的静态方法不能被覆盖为非静态方法
父类的非静态方法不能被子类覆盖为静态方法
【子父类中不能有同名方法 其中一个被static修饰】
静态方法在内存中只有一份，
无论该类有多少个实例，都共用一个内存。

静态方法可以直接使用，利用全类名调用
类名.方法名();
全包名.类名.方法名();

静态代码块:类中的静态代码块，它不存在于任何方法。
1, 在java虚拟机中类加载会执行这些静态代码块。如果类中有多个静态代码块，会从上到下依次执行。
2, 静态代码块只能定义在类里面，不能定义在方法里面。
3, 静态代码块里的变量都是局部变量，只在当前代码块内有效。
4, 静态代码块只能访问类的静态成员，而不允许访问实例成员。
5, 静态代码块用来给静态变量赋初始值。
6, 静态代码块主要用于类的初始化。它只执行一次，并在main函数之前执行。

        class Student{
		public static String name = show();
		private static int age;
		main(){
		}
		public Student(){
		   age = 20;
		}
		static{
			2
			age = 10;
		}
		 public static String show(){
			3
		  return "tom";
		 }
		}

new一个对象的时候JVM都做了那些事情:
1.之前没有进行类加载
1.类加载,同时初始化类中【静态的属性(赋默认值)】
2.执行【静态代码块】
3.分配内存空间,同时【初始化非静态的属性(赋默认值)】
4.如果声明属性的同时有显示的赋值,那么进行显示赋值把默认值覆盖
5.执行【匿名代码块】
6.执行【构造器】
7.返回内存地址
静态 > 非静态 > 构造器

  父类>子类   静态>非静态
  父类静态>子类静态>父类非静态>子类非静态>父构造器>子构造器

之前已经进行了类加载
1.分配内存空间,同时初始化非静态的属性(赋默认值)
2.如果声明属性的同时有显示的赋值,那么进行显示赋值把默认值覆盖
3.执行匿名代码块
4.执行构造器
5.返回内存地址
静态导入：
import static 包.静态方法名/静态属性名;
在当前类中就可以使用导入的静态属性或静态方法(直接方法名使用，不用类名.方法名调用);

final修饰符
final意义:
具有"不可改变的"含义，它可以修饰非抽象类、非抽象成员方法和变量。
final修饰类 ：该类不能被继承,没有子类.
final修饰变量：该变量是常量(常量池)，【只能被赋一次值】。
private int AGE = 10;
private类型的方法默认是final类型的—> final不能用来修饰构造方法，
因为"方法覆盖"这一概念仅适用于类的成员方法，而不适用于类的构造方法，父类的构造方法和子类的构造方法之间不存在覆盖关系.
因此用final修饰构造方法是无意义的。父类中用private修饰的方法不能被子类的方法覆盖.

final方法
某些情况下,出于安全原因,父类不允许子类覆盖某个方法,此时可以把这个方法声明为final类型。
final方法不能被重写（可以重载多个final修饰的方法）。
eg:Object类中的getClass()方法是final类型的—>调用任何类对象的getClass()方法就可以看到该对象的原始面目。
final变量
【final修饰非静态成员变量,必须要赋值,并且只能在下面三个地方赋值,赋值以后不能改。
声明的同时 赋值
匿名代码块内 赋值
类中任何构造器 赋值
final修饰static静态的成员变量
声明的同时 赋值
static代码块内 赋值
final修饰类不能被继承
final修饰方法不能被重写】

abstract修饰符
定义：abstract 抽象的(不完整的)，可以用来修饰类和成员方法.
abstract修饰类：抽象类。public abstract class A{}
该类不能被实例化(不能创建对象)。但是有构造器。
该类可以有抽象方法,也可以没有。可以有非抽象方法。

抽象类中可以没有抽象方法，
但包含了抽象方法的类必须被定义为抽象类。
没有抽象构造方法，也没有抽象静态方法；
抽象类中可以有成员变量,成员方法…

abstract修饰方法:抽象方法。
没有方法体。用来描述功能,但是没有实现。
被abstract 修饰的普通方法 就是抽象方法
抽象方法一定不能有代码体
public abstract void show();
包含抽象方法的类 一定是抽象类
抽象类生来就是被继承的，
子类中需要重写父类中的抽象方法，
子类中如果不想重写父类中的抽象方法,
那么子类中的该方法也要声明为抽象方法，
子类也要声明为抽象类。

抽象的类:
定义一些规范

    class BriupUtil{
 //获得数据库连接对象
 public abstract Connection getConn();
 public void insert(Object obj){}
 public void delete(int id){}
 public void update(Object obj){}
 public void find(int id){}
}
class MyDao extends BriupUtil{
	public Connction getConn(){
	 return "oracle连接对象";
	}
}

接口：
接口是为了解决了java中多继承的问题。

接口的定义:使用interface关键字定义接口
eg: public interface A{} 这个A就是接口。

接口中可以写什么
成员变量：
成员变量默认类型是 public static final类型 必须被显式初始化

成员方法:
不能有方法体.eg:public void show();
可以没有权限修饰符，默认是 public abstract

不能有任何形式的代码块
接口没有构造方法,不能被实例化–>不能 new 接口名();