JAVA 类成员初始化这一篇就够了

       在我们实际开发中，定义一个类是实在不能再平常的事，面向对象编程的理念是“一切皆是对象”，没有什么是对象不能盘的，那么我们是否真的知道类中成员初始化顺序呢？看完这篇文章你将对类成员初始化有个完整全面的认识。

一、无父类

package com.example.test;

public class Dog {

    public Dog(){
        System.out.println("Dog new instance");
    }

    //静态块
    static {
        System.out.println("Dog static blog");
    }
   
    //非静态块

    {
        System.out.println("Dog blog");
    }

}

输出结果：

Dog static blog
Dog blog
Dog new instance

是否跟你想的一样呢？所以总结一下：创建一个类的对象时，先初始化静态块，然后初始化非静态块，最后调用类的构造函数。如果类中有静态变量和非静态变量，那初始化顺序又是怎样呢？

package com.example.test;

public class Dog {
    static Cat cat1 = new Cat(1);

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }
    Cat cat = new Cat(2);
}

输出结果：

new cat instance:1
Dog static blog
Dog blog
new cat instance:2
Dog new instance

输出结果跟你预想的是否又一致呢？类中成员初始化顺序还跟定义顺序有关，也许你早知道，别喷，我只是在扫盲。那是下面这种情况呢？

package com.example.test;

public class Dog {
    public static int value = 1;

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }
    
    public static void testDog(){

    }
}

这里特别说一下调用方式为

public static void main(String[] args){
        Dog.testDog();
    }

输出结果：

Dog static blog

惊不惊喜，意不意外，说好的按上面顺序初始化的呢？一定是调用方式不对，没错，说对了，只有创建这个对象时，才会像我们最上面说的那样输出。

       如果在类中创建该类的实例又会咋样呢？我们继续往下：

package com.example.test;

public class Dog {
    public static Dog dog = new Dog();

    public static void testDog(){

    }

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }
}




package com.example.test;

public class Application {

    public static void main(String[] args){
        Dog.testDog();
    }
}

输出结果：

Dog blog
Dog new instance
Dog static blog

纳尼！！！说好的先初始化静态模块呢？前面我们说过，类成员初始化与定义顺序有关，所以调用testDog静态方法会首先调用new Dog()创建类实例，前面也提到过创建类实例会初始化非静态成员，所以进入非静态模块，然后再进入构造函数，即输出：

Dog blog
Dog new instance

而按照类的初始化顺序和定义顺序，初始化完静态变量dog之后要初始化静态模块，所以要输出“Dog static blog”，于是输出结果就是：

Dog blog
Dog new instance
Dog static blog

二、有父类  

    下面我们再来看一下存在父类的情况，这种情况我们的输出又会是怎样呢？一起看看下面的实例：

package com.example.practice.test;

public class Dog {

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }

}




package com.example.practice.test;

public class AlaskanDog extends Dog {

    public AlaskanDog(){
        System.out.println("AlaskanDog new instance");
    }

    static {
        System.out.println("AlaskanDog static blog");
    }

    {
        System.out.println("AlaskanDog blog");
    }
}

在应用启动程序中创建子类实例，输出结果：

Dog static blog
AlaskanDog static blog
Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance

我们都知道，初始化子类先要初始化父类，而类成员初始化是先初始化静态成员，所以先初始化父类静态模块，然后再是子类静态模块，注意这时候还没有调用new创建对象调用构造函数，初始化完静态模块后再调用new创建对象，而类中又有非静态成员，所以先初始化非静态成员然后再调构造函数，于是输出顺序就如上面输出。下面我们再来看一下终极实例：

package com.example.practice.test;

public class Dog {

    public Dog(){
        System.out.println("Dog new instance");
    }

    static {
        System.out.println("Dog static blog");
    }

    {
        System.out.println("Dog blog");
    }

}




package com.example.practice.test;

public class AlaskanDog extends Dog {
    private static AlaskanDog alaskanDog =  new AlaskanDog();

    private AlaskanDog(){
        System.out.println("AlaskanDog new instance");
    }

    public static AlaskanDog getInstance(){
        return new AlaskanDog();
    }

    static {
        System.out.println("AlaskanDog static blog");
    }

    {
        System.out.println("AlaskanDog blog");
    }

}



package com.example.practice.test;


public class PracticeTest {
    public static void main(String[] args){
        AlaskanDog.getInstance();
    }
}

输出结果：

Dog static blog
Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance
AlaskanDog static blog
Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance

从上面我们知道，类成员初始化跟定义顺序有关，所以AlaskanDog.getInstance()调用之后会先调用private static AlaskanDog alaskanDog = new AlaskanDog()创建对象，而创建子类会先初始化父类，所以会输出：

Dog static blog
Dog blog
Dog new instance

执行父类初始化之后执行子类对象初始化，所以就有如下输出：

AlaskanDog blog
AlaskanDog new instance

执行完private static AlaskanDog alaskanDog = new AlaskanDog()之后就要执行静态模块初始化了，因为跟先后顺序有关，所以接着就有如下输出：

AlaskanDog static blog

执行完静态模块初始化之后，再进入我们的类成员方法的调用，而我们方法内部是创建一个子类实例，所以再初始化父类和子类，而我们知道，静态变量在我们整个类域内只有一个存在，所以不会再进行初始化，所以输出如下：

Dog blog
Dog new instance
AlaskanDog blog
AlaskanDog new instance

拼接在一起就是我们程序运行输出那样。所以我们做一下总结：

1.父类初始化在子类之前；

2.静态成员初始化在非静态成员之前；

3.类成员初始化与定义顺序有关，先定义先初始化；

4.类静态成员变量在类域只有一份存在，不会重复初始化；

 

以上是这次分享，如有不正之处，请指教！