推荐：

• 从面试到入职到离职，我在B站工作的30天时光
• 爱了爱了，Alibaba顶级MySQL调优手册到手，加薪妥了
• 爱了爱了，Spring Cloud Alibaba内部微服务架构笔记真的太牛了

本文主要是想分析一下静态变量和成员变量的初始化顺序，以及如果存在父类和子类关系时，这些变量的顺序又是如何呢？本文将一一进行分析。

类加载初始化和实例对象初始化

首先我们要区分一个概念，那就是变量初始化也可以分为两大类， 一类是Java虚拟机中的类加载机制内有一个初始化，而我们实例化一个对象(即通过new关键字)时也有一个对象实例的初始化。

首先我们要知道，一个类理论上不考虑内存影响的话可以被实例化无数次，所以我们想要实例化一个对象，那么就必须要有这个类，所有类加载一定在对象实例化前面。

而静态变量是在类加载阶段就会进行初始化的（如果想详细了解Java虚拟机的类加载机制，可以点击这里），故而如果在同一个类中，那么静态变量的初始化一定在成员变量的初始化前面

静态变量和成员变量区别

我们先来看下面两句简单的代码：

package com.zwx.coreJava;

public class InitVariable {
    public static int m = 1;//静态变量(类变量)
    private int n = 2;//成员变量(实例变量)
    public static void main(String[] args) {
      	System.out.println(InitVariable.m);//直接通过类访问变量
        InitVariable initVariable = new InitVariable();//创建一个实例对象
        System.out.println(initVariable.n);//需要通过实例对象才能访问成员变量
    }
}

其中m就是静态变量，也称之为类变量，类加载之后，存储在方法区内，可以直接通过：类名.变量名进行调用。如：对象.m。

其中n就是成员变量，也称之为实例变量，属于对象实例，需要通过new一个对象之后才能引用。如：new 对象().n。成员变量的生命周期是和实例对象一致的，当实例对象被回收之后，对应的成员变量也消失了。

变量加载顺序

加下来就让我们一起结合例子验证一下变量的加载顺序

静态变量和成员变量加载顺序

首先我们建立一个父类，然后仅以父类为例子验证下静态变量和成员变量的加载顺序：

package com.zwx.coreJava;

public class SuperInitVariable {
    static String superStaticStr = "I'm Super Static Str1";
    String superInstanceStr = "I'm Super Instance Str1";

    static {
        superStaticStr = "I'm Super Static Str2";
    }
    static {
        superStaticStr = "I'm Super Static Str3";
    }

    public SuperInitVariable() {
        superInstanceStr = "I'm Super Instance Str2";
    }
}

然后新建一个测试类：

package com.zwx.coreJava;

public class TestVariableOrder {
    public static void main(String[] args) {
        System.out.println(SuperInitVariable.superStaticStr);
        SuperInitVariable superInitVariable = new SuperInitVariable();
        System.out.println(superInitVariable.superInstanceStr);
    }
}

输出结果：

I'm Super Static Str3
I'm Super Instance Str2

很明显，第一句话还没有实例化对象就可以输出静态变量，所以静态变量优先级最高，静态代码块也是一样会加载，多个代码块之间按先后顺序加载。
第二句成员变量先初始化了变量，再执行了构造器。所以可以得出如下结论：

• 1、静态变量优先级最先被初始化，多个静态代码块按代码先后顺序进行加载
• 2、成员变量先赋值，再执行构造函数

父类和子类变量加载顺序

将上面的父类简单改造一下：

package com.zwx.coreJava;

public class SuperInitVariable {
    static String superStaticStr = "I'm Super Static Str1";
    String superInstanceStr = "I'm Super Instance Str1";

    static {
        superStaticStr = "I'm Super Static Str2";
        System.out.println("Super Static：" + superStaticStr);
    }

    public SuperInitVariable() {
        superInstanceStr = "I'm Super Instance Str2";
        System.out.println("Super Construct：" + superStaticStr);
    }
}

然后再新建一个子类，继承上面的SuperInitVariable：

package com.zwx.coreJava;

public class SubInitVariable extends SuperInitVariable {
    static String subStaticStr = "I'm Sub Static Str1";
    String subInstanceStr = "I'm Sub Instance Str1";
    static {
        subStaticStr = "I'm Sub Static Str2";
        System.out.println("Sub Static：" + subStaticStr);
    }

    public SubInitVariable() {
        subInstanceStr = "I'm Sub Instance Str1";
        System.out.println("Sub Construct：" + subInstanceStr);
    }
}

然后在测试类中执行以下语句：

package com.zwx.coreJava;

public class TestVariableOrder {
    public static void main(String[] args) {
        System.out.println(SubInitVariable.subStaticStr);
    }
}

输出如下结果：

Super Static：I'm Super Static Str2
Sub Static：I'm Sub Static Str2
I'm Sub Static Str2

可以很明显看到加载顺序为：先加载父类静态变量，再加载子类静态变量
接下来再改造下测试类，我们去实例化一个SubInitVariable对象实例：

package com.zwx.coreJava;

public class TestVariableOrder {
    public static void main(String[] args) {
        SubInitVariable subInitVariable = new SubInitVariable();
    }
}

输出结果如下：

Super Static：I'm Super Static Str2
Sub Static：I'm Sub Static Str2
Super Construct：I'm Super Static Str2
Sub Construct：I'm Sub Instance Str1

可以很明显的得出如下结论：

• 1、初始化父类静态变量。
• 2、初始化子类静态变量。
• 3、初始化父类成员变量。
• 4、加载父类构造器。
• 5、初始化子类成员变量。
• 6、加载子类构造器。

或者说可以分的更细致一点，可以总结为如下：

• 1、初始化父类静态变量。
• 2、初始化父类静态代码块。
• 3、初始化子类静态变量。
• 4、初始化子类静态代码块。
• 5、初始化父类成员变量。
• 6、加载父类构造器。
• 7、初始化子类成员变量。
• 8、加载子类构造器。

引用类加载顺序

上面的例子中变量都是String类型的，那么假如变量是引用类型呢？又会怎么样？
我们再来看个例子。新建两个类，其中一个类引用另一个类：

package com.zwx.coreJava;

public class ReferenceObj {
    static String referenceStaticStr;
    String referenceInstanceStr;

    static {
        referenceStaticStr = "I'm reference Static Str";
        System.out.println(referenceStaticStr);
    }

    public ReferenceObj() {
        referenceInstanceStr = "I'm reference Construct Str";
        System.out.println(referenceInstanceStr);
    }
}

package com.zwx.coreJava;

public class InitReferenceVariable {
    static ReferenceObj staticObj;
    ReferenceObj obj;

    static {
        System.out.println("static code：" + staticObj);
    }

    public InitReferenceVariable() {
        System.out.println("construct code：" + obj);
    }
}

上面例子中看到，我们只是持有了另一个对象的引用，不做任何初始化动作，这时候是否会去加载引用类呢？我们新建一个测试类测试一下：

package com.zwx.coreJava;

public class TestVariableOrder {
    public static void main(String[] args) {
        //测试引用变量和数组
        System.out.println(InitReferenceVariable.staticObj);
        InitReferenceVariable initReferenceVariable = new InitReferenceVariable();
        System.out.println(initReferenceVariable.obj);
    }
}

输出如下结果：

static code：null
null
construct code：null
null

可以看到，引用类ReferenceObj没有被实例化也没有被加载。
那么我们把上面的变量进行初始化修改一下：

static ReferenceObj staticObj = new ReferenceObj();
ReferenceObj obj = new ReferenceObj();

再次运行测试类，输出如下结果：

I'm reference Static Str
I'm reference Construct Str
static code：com.zwx.coreJava.ReferenceObj@4b1210ee
com.zwx.coreJava.ReferenceObj@4b1210ee
I'm reference Construct Str
construct code：com.zwx.coreJava.ReferenceObj@4d7e1886

可以看到：I’m reference Static Str只输出了1次，而I’m reference Construct Str输出了2次，这是因为同一个类只会被加载1次，但是我们new了两次，也就是实例化了2次，所以构造函数会执行2次。
根据这个结果我们可以得出如下结论：

• 1、一个类假如只是引用另一个类而没有被实例化，那么不会触发引用类的类加载和实例化
• 1、一个类假如引用另一个类并且实例化了引用类，那么会优先加载引用类和实例化引用类

数组引用类加载顺序

把类改造如下：

package com.zwx.coreJava;

public class InitReferenceVariable {
    static ReferenceObj[] arr = new ReferenceObj[10];
}

然后在测试类中输出如下语句：

System.out.println("输出数组：" + InitReferenceVariable.arr);

输出结果如下：

输出数组：[Lcom.zwx.coreJava.ReferenceObj;@4b1210ee

可以看到只会输出这一句话，而不会触发ReferenceObj的类加载和初始化。
可以得出如下结论：
如果将引用类作为数组对象，那么创建数组的时候不会触发数组对象的类加载和初始化

总结

本文从父类，子类，引用类，以及数组引用类的角度全面分析了什么时候会触发一个类的加载，什么时候会触发一个类的实例化。而一个类在加载的时候就会初始化静态变量，一个类在实例化的时候就会触发成员变量的初始化。本文涉及到类加载时并没有特别深入的介绍，有兴趣的，可以看下本人下的JVM虚拟机系列2中讲述的类加载机制，相信看完之后会有更加深刻的理解和体会。

来源：http://002ii.cn/?T0vKxr