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

时间:2020-9-3 作者:admin


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

前言

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中讲述的类加载机制,相信看完之后会有更加深刻的理解和体会。
请关注我,和孤狼一起学习进步

声明:本文内容由互联网用户自发贡献自行上传,本网站不拥有所有权,未作人工编辑处理,也不承担相关法律责任。如果您发现有涉嫌版权的内容,欢迎进行举报,并提供相关证据,工作人员会在5个工作日内联系你,一经查实,本站将立刻删除涉嫌侵权内容。