一篇文章搞懂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 heaboy@heaboy.com
 * @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、静态优先于非静态

类加载顺序为（默认变量卸载代码块前）

父类静态变量->父类静态语句块->子类静态变量->子类静态语句块->父类普通成员变量->父类动态语句块->父类构造器->子类普通成员变量->子类动态语句块->子类构造器