JAVA类成员初始化顺序详解


本文章总共提供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 构造函数

把输出结果对照以上的源代码，可以看出出过初始化一个类加载顺
c0c8
序如下。

一、同一个类的加载顺序，静态成员(静态变量、静态块) > 自定义变量 > 构造函数，静态成员的加载是按照类中定义的先后顺序加载的。

二、父亲类、子类的加载顺序，父亲所有的静态成员 > 子类的所有静态成员 > 父亲的所有自变量  > 父亲构造函数 > 子类自定义变量 > 子类构造函数。

参考以上输出结果，需要注意的地方。

    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

     通过以上输出结果可以看出，其父类还是按照 父亲所有静态成员 > 父亲自定义成员  > 构造函数规则。但是变化在本类中。原因是因为，在本类中创建了自己的静态对象。

当调用构造函数的时候，则必定按照规则初始化父类的成员(先所有静态.....)；而本类中因为静态成员时按照顺序初始化，因此先执行构造函数里面的代码，而构造函数之前必定初始化了自定义的成员，因此sub2SonTestIntVal 输出值为2.。然后再继续执行后面的静态成员。