Java 初始化执行顺序以及成员变量初始化顺序

一、静态变量初始化顺序

大家先看两个例子：

（1）

public class SingleTon {
    public static int count1;
    public static int count2 = 1;
    private static SingleTon singleTon = new SingleTon();
    
    private SingleTon() {
        count1++;
        count2++;
    }

    public static SingleTon getInstance() {
        return singleTon;
    }
}

class Test {
    public static void main(String[] args) {
        SingleTon singleTon = SingleTon.getInstance();
        System.out.println("count1=" + singleTon.count1);
        System.out.println("count2=" + singleTon.count2);
    }
}

输出

count1=1
count2=2

（2）

public class SingleTon {

    private static SingleTon singleTon = new SingleTon(); //（1）这一步初始化后，count1=1，count2=1
    public static int count1; //（2）这一步只是定义了count1变量，并未进行count1初始化，因此count1 =1 count2=1
    public static int count2 = 3;//（3）这一步 进行count2初始化，因此将原来的值覆盖，因此count2=3，count1 =1

    private SingleTon() {
        count1++; // 此时，count1还未被初始化，因此初始值为0，++后值为1
        count2++; // 此时，count2还未被初始化，因此初始值为0，++后值为1
    }

    public static SingleTon getInstance() {
        return singleTon;
    }
}

class Test {
    public static void main(String[] args) {
        SingleTon singleTon = SingleTon.getInstance();
        System.out.println("count1=" + singleTon.count1);
        System.out.println("count2=" + singleTon.count2);
    }
}

 

count1=1

count2=3

 

在调用类静态成员（不管是方法还是变量）的时候，按顺序初始化静态属性和代码块，之后才会调用静态方法，非静态成员变量因为没有初始化类，故不会初始化。

 

二、继承中的初始化

看两个例子：

(1)

class Meal {
    Meal() {
        System.out.println("Meal()");
    }
}

class Bread {
    Bread() {
        System.out.println("Bread()");
    }
}

class Cheese {
    Cheese() {
        System.out.println("Cheese()");
    }
}

class Lettuce {
    Lettuce() {
        System.out.println("Letuce()");
    }
}

class Lunch extends Meal {
    Lunch() {
        System.out.println("Lunch()");
    }
}

class PortabLunch extends Lunch {
    PortabLunch() {
        System.out.println("PortabLunch");
    }
}

public class Main extends  PortabLunch{
    Bread bread = new Bread();
    Cheese cheese = new Cheese();
    Lettuce lettuce = new Lettuce();

    Main() {
        System.out.println("Main");
    }

    public static void main(String[] args) {
        new Main();
    }
}

输出:

Meal()
Lunch()
PortabLunch
Bread()
Cheese()
Letuce()
Main

 

说明：子类初始化前要(0)在其他任何事情发生之前，将分配给对象的存储空间初始化为二进制零（1）寻找父类构造器，并且步骤会不断递归，直到找到根类为止。然后自顶向下，逐层调用构造函数，直到最底层的父类构造器。（2）然后按照代码编译顺序依次初始化各成员变量 （3）最后调用本类的构造函数进行初始化。

（2）

public class Glyph {
    void draw() {
        System.out.println("Glphy draw()");
    }

    Glyph() {
        System.out.println("Glphy() before draw");
        draw();//当子类调用父类构造器的时候，父类其实尚未初始化，因此调用的是子类的draw方法
        System.out.println("Glphy() after draw");
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;

    RoundGlyph(int r) {
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph(),radius:" + radius);
    }

    void draw() {
        System.out.println("RoundGlyph.draw(),radius:" + radius);
    }
}

class PolyConstruct {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}

输出

Glphy() before draw
RoundGlyph.draw(),radius:0
Glphy() after draw
RoundGlyph.RoundGlyph(),radius

 

说明：在调用父类构造器时，因为draw方法被子类RoundGlyph覆写，因此在Glyph中调用的是子类的draw方法，并且此时由于radius还未进行初始化，因此其值是默认的初始值0.

(3)

public class Glyph {
    void draw() {
        System.out.println("Glphy draw()");
    }

    Glyph() {
        System.out.println("Glphy() before draw");
        draw();//当子类调用父类构造器的时候，父类其实尚未初始化，因此调用的是子类的draw方法
        System.out.println("Glphy() after draw");
    }
}

class RoundGlyph extends Glyph {
    private int radius = 1;

    RoundGlyph(int r) {
        radius = r;
        System.out.println("RoundGlyph.RoundGlyph(),radius:" + radius);
    }

//    void draw() {
//        System.out.println("RoundGlyph.draw(),radius:" + radius);
//    }
}

class PolyConstruct {
    public static void main(String[] args) {
        new RoundGlyph(5);
    }
}

输出:

Glphy() before draw
Glphy draw()
Glphy() after draw
RoundGlyph.RoundGlyph(),radius:5

　　

 说明:本例子中，子类RoundGlyph中不包含draw方法，因此也就不存在覆写的问题。所以父类初始化时调用的是本类中的draw方法。

 

通过例子（2）（3）说明，在编写构造器时需要遵循一条准则:"用尽可能简单的方法使得对象进入正常状态；如果可以的话，尽量避免调用其他的方法"。在构造器内能够被唯一安全调用的方法是基类中的final方法（或者是private方法，因为它自动属于final方法），这些方法不能被覆盖，因此也不会 出项一些奇怪的问题。

下面附一张，JAVA成员变量初始化思维导图，对于理解这一块的知识很有帮助

 

 

 

详细可参考这一文章：https://blog.csdn.net/fly_grass_fish/article/details/81116348   java静态变量static初始化顺序