Java初始化順序（靜態變量、靜態初始化塊、實例變量、實例初始化塊、構造方法）

1、執行順序

1.1、一個類中的初始化順序

類內容（靜態變量、靜態初始化塊） => 實例內容（變量、初始化塊、構造器）

1.2、兩個具有繼承關系類的初始化順序

父類的（靜態變量、靜態初始化塊）=> 子類的（靜態變量、靜態初始化塊）=> 父類的（變量、初始化塊、構造器）=> 子類的（變量、初始化塊、構造器）

示例如下：（結果見注釋）

class A {
    public A() {
        System.out.println("Constructor A.");
    }

    {
        System.out.println("Instance Block A.");
    }
    static {
        System.out.println("Static Block A.");
    }

    public static void main(String[] args) {
        new A();/*
                 * Static Block A. Instance Block A. Constructor A.
                 */
    }
}

class B extends A {
    public B() {
        System.out.println("Constructor B.");
    }

    {
        System.out.println("Instance Block B.");
    }
    static {
        System.out.println("Static Block B.");
    }

    public static void main(String[] args) {
        new A();/*
                 * Static Block A. Static Block B. Instance Block A. Constructor A.
                 */
        System.out.println();
        new B();/*
                 * Instance Block A. Constructor A. Instance Block B. Constructor B.
                 */// 靜態成員和靜態初始化塊只會執行一次。
    }
}

2、對變量值的影響

一個變量，若顯示初始化、初始化塊對該變量賦值、構造方法對該變量賦值同時存在，則變量最終值如何確定？按1節中所述的執行順序確定。

這里考慮初始化塊在變量定義之前的情形，此時會造成迷惑。

 

初始化塊可以對在它之后定義的變量賦值，但不能訪問（如打印）。如：

    static {
        a = 3;
        // int b=a;//Cannot reference a field before it is defined
        // System.out.println(a);//Cannot reference a field before it is defined
    }
    static int a = 1;

“對變量值的影響”是指 對變量賦值的初始化塊位於變量定義之前 時，變量的最終值根據變量定義時是否顯示初始化而會有不同結果（若初始化塊位於變量定義之后，那么變量的值顯然很容易就確定了，不會造成迷惑）。如：

class Test {
    static {
        a = 3;
        // int b=a;//Cannot reference a field before it is defined
        // System.out.println(a);//Cannot reference a field before it is defined
        b = 3;
    }
    static int a = 1;
    static int b;

    public static void main(String[] args) {
        System.out.println(a);//1
        System.out.println(b);//3
    }
}

判斷方法：

顯示初始化內部隱含 定義變量和對變量進行賦值的初始化塊兩部分，所以初始化塊和顯示初始化哪個在后變量的最終值就是該值。

更多示例：

1：

class C {

    static {
        a = 2;
        b = 2;
    }
    static int a;
    static int b = 1;

    public C() {
        e = 3;
    }

    {
        c = 2;
        d = 2;
        e = 2;
    }
    int c;
    int d = 1;
    int e = 1;

    public static void main(String[] args) {
        System.out.println(C.a);//2
        System.out.println(C.b);//1
        System.out.println(new C().c);//2
        System.out.println(new C().d);//1
        System.out.println(new C().e);//3
    }

2：

class C {
    public C() {
    }

    {
        a = 3;
    }
    static {
        a = 2;
    }
    static int a;
    static int b;

    public static void main(String[] args) {
        System.out.println(C.a);// 2
        System.out.println(new C().a);// 3
        System.out.println(C.b);// 0
    }
}

3：

class C {
    // 以下關於靜態初始化的
    static {
        a = 2;
    }
    static int a = 1;
    static int b = 1;
    static {
        b = 2;
        c = 2;
    }
    static int c;

    {
        d = 2;
    }
    int d = 1;
    int e = 1;
    {
        e = 2;
        f = 2;
    }
    int f;

    public static void main(String[] args) {
        System.out.println(C.a);// 1
        System.out.println(C.b);// 2
        System.out.println(new C().c);// 2
        System.out.println(new C().d);// 1
        System.out.println(new C().e);// 2
        System.out.println(new C().f);// 2
    }
}

 3、總結

執行順序：

1、類內容（靜態變量、靜態初始化塊） => 實例內容（變量、初始化塊、構造器）

2、父類的（靜態變量、靜態初始化塊）=> 子類的（靜態變量、靜態初始化塊）=> 父類的（變量、初始化塊、構造器）=> 子類的（變量、初始化塊、構造器）

 

初始化塊可以對在它之后定義的變量賦值，但不能訪問（如打印）。

變量最終值：一個變量，若顯示初始化、初始化塊對該變量賦值、構造方法對該變量賦值同時存在，則變量最終值如何確定：

1、按執行順序

2、若對變量賦值的初始化塊在變量定義前時：若變量顯示初始化了則最終為顯示初始化值，否則為初始化塊的賦值。

 

 

注：凡事總有例外，實例初始化也可能位於類靜態初始化前，示例：

public class StaticTest {

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

    static StaticTest st = new StaticTest();

    static {
        System.out.println("1");
    }

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

    StaticTest() {
        System.out.println("3");
        System.out.println("a=" + a + ",b=" + b);
    }

    public static void staticFunction() {
        System.out.println("4");
    }

    int a = 110;
    static int b = 112;
}

結果如下：
2
3
a=110,b=0
1
4