静态变量，成员变量初始化顺序分析

前言
类加载初始化和实例对象初始化
静态变量和成员变量区别
变量加载顺序

静态变量和成员变量加载顺序
父类和子类变量加载顺序
引用类加载顺序
数组引用类加载顺序

总结

前言

Core Java系列主要会讲述一些Java必备的一些核心技术相关知识点，力求以查询补漏的方式对Java核心的基础知识进行总结分享，希望能和大家一起交流，如果有理解错误的地方，还请大家指正。

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

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

首先我们要区分一个概念，那就是变量初始化也可以分为两大类，一类是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
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);