【Core Java系列1】一文讲透父子类中静态变量，成员变量初始化顺序原理
静态变量，成员变量初始化顺序分析
- 前言
- 类加载初始化和实例对象初始化
- 静态变量和成员变量区别
- 变量加载顺序
-
- 静态变量和成员变量加载顺序
- 父类和子类变量加载顺序
- 引用类加载顺序
- 数组引用类加载顺序
- 总结
前言
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);
输出结果如下：
输出数组：[Lcom.zwx.coreJava.ReferenceObj;@4b1210ee
可以看到只会输出这一句话，而不会触发ReferenceObj的类加载和初始化。
可以得出如下结论：
如果将引用类作为数组对象，那么创建数组的时候不会触发数组对象的类加载和初始化
总结
本文从父类，子类，引用类，以及数组引用类的角度全面分析了什么时候会触发一个类的加载，什么时候会触发一个类的实例化。而一个类在加载的时候就会初始化静态变量，一个类在实例化的时候就会触发成员变量的初始化。本文涉及到类加载时并没有特别深入的介绍，有兴趣的，可以看下本人下的JVM虚拟机系列2中讲述的类加载机制，相信看完之后会有更加深刻的理解和体会。
请关注我，和孤狼一起学习进步。