JAVA类成员初始化顺序详解

最新推荐文章于 2022-07-12 21:21:30 发布

andboby

最新推荐文章于 2022-07-12 21:21:30 发布

阅读量274

点赞数

分类专栏： JAVA ANDROID 文章标签： JAVA JAVA类加载 JAVA成员初始化顺序

本文链接：https://blog.csdn.net/wangqiubo2010/article/details/71774102

版权

ANDROID 同时被 2 个专栏收录

33 篇文章 0 订阅

订阅专栏

JAVA

14 篇文章 0 订阅

订阅专栏

本文章总共提供4个单元测试类，main类UnitMainTest，祖先类UnitSuperClass，父亲类UnitSubClass，叶子节点类UnitSon2SubClass。

4个类的代码块如下：

一、祖先类UnitSuperClass。
public class UnitSuperClass {

    static {
        System.out.println("superclass init");
    }

public static int value = 123;

    public UnitSuperClass(){
        System.out.println("UnitSuperClass 自定义变量值superTestIntVal: " + superTestIntVal);
        System.out.println("UnitSuperClass 构造函数");
    }

    public int superTestIntVal = 2;
}
二、父亲类UnitSubClass。
public class UnitSubClass extends UnitSuperClass {
    static {
        System.out.println("subclass init");
    }

    public UnitSubClass(){
        System.out.println("UnitSubClass 自定义变量值subTestIntVal: " + subTestIntVal);
        System.out.println("UnitSubClass 构造函数");
    }

public int subTestIntVal = 2;

}
三、叶子节点类UnitSon2SubClass。
public class UnitSon2SubClass extends UnitSubClass {
    //public static UnitSon2SubClass unitSon2SubClass = new UnitSon2SubClass();
    public static int son2SubValOne = 5;
    public static int son2SubValTwo;

public static final int UnitSon2SubIntVal = 3;

    static {
        System.out.println("UnitSon2SubClass init");
        System.out.println("UnitSon2SubIntVal: " + UnitSon2SubIntVal);
        System.out.println("静态块中输出son2SubValOne: " + son2SubValOne);
        System.out.println("静态块中输出son2SubValTwo: " + son2SubValTwo);
    }

public static final int UnitSon2SubIntValAfterStaticFile = 4;

    public UnitSon2SubClass(){
        son2SubValOne++;
        son2SubValTwo++;
        System.out.println("构造函数中输出son2SubValOne: " + son2SubValOne);
        System.out.println("构造函数中输出son2SubValTwo: " + son2SubValTwo);

System.out.println("UnitSon2SubClass 自定义变量值sub2SonTestIntVal: " + sub2SonTestIntVal

);
System.out.println("UnitSon2SubClass 构造函数");
}

   // public static UnitSuperClass getInstance(){
   //     return unitSon2SubClass;
   // }

public int sub2SonTestIntVal = 2;
}

四、main类UnitMainTest。
public class UnitMainTest {
public static void main(String[] args) {

// System.out.println(UnitSubClass.value);// 被动应用1
//
// UnitSubClass[] sca = new UnitSubClass[10];// 被动引用2

// UnitSon2SubClass.getInstance();

     UnitSon2SubClass unitSon2SubClass = new UnitSon2SubClass();

}
}

运行单元测试main类，输出结果会是怎样呢，见如下结果，即是在外边创建对象。
输出结果：
superclass init
subclass init
UnitSon2SubClass init
UnitSon2SubIntVal: 3
静态块中输出son2SubValOne: 5
静态块中输出son2SubValTwo: 0
UnitSuperClass 自定义变量值superTestIntVal: 2
UnitSuperClass 构造函数
UnitSubClass 自定义变量值subTestIntVal: 2
UnitSubClass 构造函数
构造函数中输出son2SubValOne: 6
构造函数中输出son2SubValTwo: 1
UnitSon2SubClass 自定义变量值sub2SonTestIntVal: 2
UnitSon2SubClass 构造函数

把输出结果对照以上的源代码，可以看出出过初始化一个类加载顺序如下。
一、同一个类的加载顺序，静态成员(静态变量、静态块) > 自定义变量 > 构造函数，静态成员的加载是按照类中定义的先后顺序加载的。
二、父亲类、子类的加载顺序，父亲所有的静态成员 > 子类的所有静态成员 > 父亲的所有自变量 > 父亲构造函数 > 子类自定义变量 > 子类构造函数。
参考以上输出结果，需要注意的地方。
    1、请查看UnitSon2SubClass 类中的静态块和构造函数的输出结果，为什么son2SubValOne，son2SubValTwo在静态块中输出的为5 和 1，而不是6 和 1；
    原因很简单，因为按照同一个类的初始化顺序，首先调用沟站函数生成静态的成员对象，然后呢会初始化son2SubValOne = 5，而 son2SubValTwo没有初始化值，
    因此输出结果为 5、1，5是初始化的值覆盖了构造函数的自动加1，而son2SubValTwo =1，是因为没有给他赋值，则还是构造函数自动增加的值。
    如果 public static int son2SubValOne = 0 public static int son2SubValTwo ;，输出结果会是怎样？0,1或者0,0或者1,1；正确的则是0,1。
    因为，按照静态变量的初始化顺序，静态对象unitSon2SubClass需要提前创建，则执行构造函数后，结果为 son2SubValOne = 1，son2SubValTwo = 1；
    然后执行public static int son2SubValOne = 0 public static int son2SubValTwo；则son2SubValOne = 0，son2SubValTwo未被初始化则还是构造函数中的值1.
    2、如果执行以下代码，结果会是怎样？
  public class UnitMainTest {
   public static void main(String[] args) {

    System.out.println(UnitSubClass.value);// 被动应用1
//
//         UnitSubClass[] sca = new UnitSubClass[10];// 被动引用2
//
//   UnitSon2SubClass.getInstance();

   }

  }

  输出结果如下：
   superclass init
   123
  则说明，如果是子类调用父亲类的静态成员，则只会初始化被调用的类即是初始化了父亲类，而子类UnitSubClass本身并未被初始化。
3、如果代码改成以下，结果又会如何呢？
  public class UnitMainTest {
   public static void main(String[] args) {

  //        System.out.println(UnitSubClass.value);// 子类调用父亲类静态成员
    System.out.println(UnitSon2SubClass.son2SubValOne);// 类调用自己的静态成员
  //        UnitSubClass[] sca = new UnitSubClass[10];// 创建数组
  //        UnitSon2SubClass.getInstance();

   }
  }
  输出结果如下：
    superclass init
    subclass init
    UnitSon2SubClass init
    UnitSon2SubIntVal: 3
    静态块中输出son2SubValOne: 5
    静态块中输出son2SubValTwo: 0
    5
   从结果中可看出，如果调用类的静态成员时，如果本类拥有父亲类，则必须按顺序先初始化父亲类的所有静态成员，然后再按顺序初始化本类的所有静态成员，最后才执行调用的本成员的代码。

  3、如果代码改成以下，结果又会如何呢？
   public class UnitMainTest {
    public static void main(String[] args) {

   //        System.out.println(UnitSubClass.value);// 子类调用父亲类静态成员
   //    System.out.println(UnitSon2SubClass.son2SubValOne);// 类调用自己的静态成员
           UnitSubClass[] sca = new UnitSubClass[10];// 创建数组
   //        UnitSon2SubClass.getInstance();

    }
   }
     本代码无输出结果，因此，定义数组，类不执行初始化操作。

4、如果放开 UnitSon2SubClass注释的内部创建的静态对象(第一行)，并放开getInstance()。

public class UnitMainTest {
    public static void main(String[] args) {

//        System.out.println(UnitSubClass.value);// 子类调用父亲类静态成员
//       System.out.println(UnitSon2SubClass.son2SubValOne);// 类调用自己的静态成员
//        UnitSubClass[] sca = new UnitSubClass[10];// 创建数组
        UnitSon2SubClass.getInstance();

//        UnitSon2SubClass unitSon2SubClass = new UnitSon2SubClass();

    }
}

以上输出结果会是怎样的呢？

    运行单元测试main类，输出结果会是怎样呢，见如下结果。
    输出结果：
    superclass init
    subclass init
     UnitSuperClass 自定义变量值superTestIntVal: 2
    UnitSuperClass 构造函数
    UnitSubClass 自定义变量值subTestIntVal: 2
    UnitSubClass 构造函数
    构造函数中输出son2SubValOne: 1
    构造函数中输出son2SubValTwo: 1
    UnitSon2SubClass 自定义变量值sub2SonTestIntVal: 2
    UnitSon2SubClass 构造函数
    UnitSon2SubClass init
    UnitSon2SubIntVal: 3
    静态块中输出son2SubValOne: 5
    静态块中输出son2SubValTwo: 1