一篇文章搞懂java中类以及static关键字执行顺序
我们先看看类的生命周期
类的生命周期
- 加载：classpath、jar包、网络、某个磁盘位置下的类的class二进制字节流读进来，在内存中生成一个代表这个类的java.lang.Class对象放入元空间（方法区，永久代），此阶段我们程序员可以干预，我们可以自定义类加载器来实现类的加载；
- 验证：验证Class文件的字节流中包含的信息符合《Java虚拟机规范》的全部约束要求，保证虚拟机的安全；
- 准备：类变量赋默认初始值，int为0，long为0L，boolean为false，引用类型为null；常量赋正式值；
- 解析：把符号引用翻译为直接引用；
- 初始化：当我们new一个类的对象，访问一个类的静态属性，修改一个类的静态属性，调用一个类的静态方法，用反射API对一个类进行调用，初始化当前类，其父类也会被初始化… 那么这些都会触发类的初始化；
静态变量的初始化有两种途径： （1）在静态变量的声明处进行初始化 （2）在静态代码块中进行初始化
- 使用：使用这个类；
- 卸载：
1.该类所有的实例都已经被GC，也就是JVM中不存在该Class的任何实例；
2.加载该类的ClassLoader已经被GC；
3.该类的java.lang.Class 对象没有在任何地方被引用，如不能在任何地方通过反射访问该类的方法；
接着我们来了解static关键字的作用和使用条件
static关键字
static关键字修饰的数据存储在我们的方法区中的静态常量池中，static可以修饰方法、变量和代码块
static修饰方法：
- 指定不需要实例化就可以激活的一个方法。
- this关键字不能再static方法中使用
- 静态方法中不能使用非静态方法
- 非静态方法可以调用静态方法。
static修饰变量：
- 指定变量被所有对象共享，即所有实例都可以使用该变量。
- 变量属于这个类。
static修饰代码块：
- 无论放在哪里，都是放在main方法运行的。
- 通常用于初始化静态变量，静态代码块属于类。
- 不可以省略，没加static认为是构造代码块
static关键字执行顺序
先记住几个准则
- 实例化对象前，先加载类（对象载入之前，一定要是类先被载入）
- 类（或者静态变量和静态代码块）在生命周期结束前，只执行一次
- 静态变量（属性）和静态代码块谁先声明谁先执行
- 非静态变量（属性）和非静态代码块谁先声明谁先执行
- 静态构造代码块是和类同时加载的，构造代码块是在实例化之后执行构造方法之前执行的
- 构造方法是在构造代码块执行完之后才执行的。
- 静态方法属于类的，加载完类就可以调用静态方法（可以执行多次）；非静态方法是属于对象的，加载完对象就可以调用非静态方法。
- 每创建一个对象，即每载入一个对象，非静态代码块都执行一次。执行类对象的载入之前就会调用
我们来通过一个例子来验证以下上面的观点
InitializeDemo.java
package com.qcby.demo.staticDemo;
/**
* @ClassName TRRest
* @Description TODO
* @Author [email protected]
* @Version 1.0.0
*/
public class InitializeDemo {
private static int k = 1;
private static InitializeDemo t1 = new InitializeDemo("t1");
private static InitializeDemo t2 = new InitializeDemo("t2");
private static int i = print("i");
private static int n = 99;
{
print("初始化块");
j=100;
}
public InitializeDemo(String str) {
System.out.println((k++) + ":" + str + " i=" + i + " n=" + n);
++i;
++n;
}
static {
print("静态块");
n=100;
}
private int j = print("j");
public static int print(String str) {
System.out.println((k++) + ":" + str + " i=" + i + " n=" + n);
++n;
return ++i;
}
public static void main(String[] args) {
InitializeDemo test = new InitializeDemo("test");
}
}
输出结果
我们来逐个分析，
一开始调用main方法，main方法内实例化InitializeDemo的对象，在对象载入之前，一定要是类先被载入
所以我们先加载InitializeDemo类，加载类的同时，会加载静态变量和静态代码块，但是是按顺序执行，且只执行一次
先加载如下静态变量
private static int k = 1;
加载如下静态变量的时候，发现要去加载类，由于类以及加载了，所以会加载这个对象，这个对象加载前，会执行非静态代码块
private static InitializeDemo t1 = new InitializeDemo("t1");
此时也就是
1:初始化块 i=0 n=0
接着执行
private int j = print("j");
2:j i=1 n=1
接着执行构造方法，
public InitializeDemo(String str) {
System.out.println((k++) + ":" + str + " i=" + i + " n=" + n);
++i;
++n;
}
3:t1 i=2 n=2
t1的实例化执行结束，接着执行t2的实例化
private static InitializeDemo t2 = new InitializeDemo("t2");
结果和上述一致，按非静态代码块和非静态属性然后构造方法方法的顺序执行
4:初始化块 i=3 n=3
5:j i=4 n=4
6:t2 i=5 n=5
两个静态属性（实例化）执行完，执行如下代码
private static int i = print("i");
7:i i=6 n=6
接着执行下面的代码，此时n变成了99
private static int n = 99;
接着执行静态代码块
static {
print("静态块");
n=100;
}
8:静态块 i=7 n=99
类加载完毕，执行test对象的载入，参考t1，t2的实例化，按非静态代码块和非静态属性然后构造方法方法的顺序执行
9:初始化块 i=8 n=100
10:j i=9 n=101
11:test i=10 n=102
继承中的static执行顺序
例子一
package com.qcby.demo.oop;
public class Test3 extends Base {
static {
System.out.println("test static");
}
public Test3(){
System.out.println("test constructor");
}
public static void main(String[] args) {
new Test3();
}
}
class Base{
static {
System.out.println("Base static");
}
public Base(){
System.out.println("Base constructor");
}
}
执行Test3的构造方法，要先加载Test3的类加载，由于Test3继承于Base，所以他要先加载父类Base，
所以先Base static 后test static 在执行子类的构造方法的时候，要先执行父类的构造方法，如果是多级继承,会先执行最顶级父类的构造方法,然后依次执行各级个子类的构造方法。 所以先执行Base constructor后执行test constructor结果就如上图
例子二（重点）
package com.qcby.demo.oop;
public class MyTest {
MyPerson person = new MyPerson("test");//这里可以理解为成员变量辅助，，要先把MyPerson先加载到jvm中
static {
System.out.println("test static");//1
}
public MyTest() {
System.out.println("test constructor");//5
}
public static void main(String[] args) {
//main方法在MyTest类中，使用mian方法先加载MyTest的静态方法，不调用其他，
MyClass myClass =new MyClass();//对象创建的时候，会加载对应的成员变量
}
}
class MyPerson {
static {
System.out.println("person static");//3
}
public MyPerson(String str) {
System.out.println("person " + str);//4 6
}
}
class MyClass extends MyTest {
MyPerson person = new MyPerson("class");//这里可以理解为成员变量辅助，要先把MyPerson先加载到jvm中
static {
System.out.println("class static");//2
}
public MyClass() {
//默认super()
System.out.println("class constructor");//7
}
}
1.先看main方法，main方法回先加载对应的类，此时MyTest类和其静态的变量，方法和代码块会随类的加载而开辟空间。static是属于类的。所以test static优先执行，且此时MyTest类的其他语句不执行。
2.mian方法中调用了MyClass myClass =new MyClass()，实例化了一个MyClass类的对象，这时候会初始化对象的成员变量和调用对象的构造函数，而MyClass类继承于MyTest类，在加载MyClass类前，会先调用MyTest类，但是MyTest类以及其静态的变量，方法和代码块已经加载（在类的生命周期只执行一次），所以返回到子类（MyClass类）的加载，这时候会调用MyClass类的静态的变量，方法和代码块。所以class static第二个执行。
3.MyClass类加载完后，应该接着调用MyClass类的构造方法，在调用子类的构造方法前，会默认调用父类的无参构造方法(super()省略)，调用父类的无参构造方法，相当于实例化父类的对象，这时候会先初始化对象的成员变量，这里的MyPerson person = new MyPerson(“test”);就相当于成员变量（属于对象，在对象的实例化的时候才加载），于是会加载MyPerson类和其静态的变量，方法和代码块。所以person static第三个执行
4.加载完MyPerson类和其静态的变量，方法和代码块后，会调用MyPerson类和的有参构造方法，即person test第四个执行
5.MyPerson类和的有参构造方法执行结束，返回父类MyTest，父类调用构造方法，即test constructor第五个执行
6.父类MyTest构造方法执行结束，返回子类，子类再调用构造方法前，先初始化对象的成员变量MyPerson person = new MyPerson(“class”);，这时候会先先加载MyPerson 和其静态的变量，方法和代码块。由于上述类以及加载，所以直接执行其有参构造方法，即person class第六个执行
7.MyPerson类和的有参构造方法执行结束，返回子类MyClass，子类调用构造方法，即class constructor第七个执行
父类static代码块–>子类static代码块–>父类普通代码块（成员对象属性初始化）–>父类构造方法–>子类普通代码块（成员对象属性初始化–>子类构造方法
总结
类加载顺序的三个原则是
1、父类优先于子类
2、属性和代码块（看先后顺序）优先于构造方法
3、静态优先于非静态
类加载顺序为（默认变量卸载代码块前）
父类静态变量->父类静态语句块->子类静态变量->子类静态语句块->父类普通成员变量->父类动态语句块->父类构造器->子类普通成员变量->子类动态语句块->子类构造器