【Core Java系列1】一文讲透父子类中静态变量，成员变量初始化顺序原理

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

---

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

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);