淺談Java變量的初始化順序詳解

規則1（無繼承情況下）：
對於靜態變量、靜態初始化塊、變量、初始化塊、構造器，它們的初始化順序依次是
（靜態變量、靜態初始化塊）>（變量、初始化塊）>構造器
證明代碼：
代碼如下：

public class InitialOrderTest {
    // 靜態變量
    public static String staticField = "靜態變量";
    // 變量
    public String field = "變量";
    // 靜態初始化塊
    static {
        System.out.println(staticField);
        System.out.println("靜態初始化塊");
    }
    // 初始化塊
    {
        System.out.println(field);
        System.out.println("初始化塊");
    }
    // 構造器
    public InitialOrderTest() {
        System.out.println("構造器");
    }
    public static void main(String[] args) {
        new InitialOrderTest();
    }
}

結果顯示：
靜態變量
靜態初始化塊
變量
初始化塊
構造器

規則2（有繼承情況下）：
子類的靜態變量和靜態初始化塊的初始化是在父類的變量、初始化塊和構造器初始化之前就完成
代碼如下：

class Parent {
    // 靜態變量
    public static String p_StaticField = "父類--靜態變量";
    // 變量
    public String p_Field = "父類--變量";
    // 靜態初始化塊
    static {
        System.out.println(p_StaticField);
        System.out.println("父類--靜態初始化塊");
    }
    // 初始化塊
    {
        System.out.println(p_Field);
        System.out.println("父類--初始化塊");
    }
    // 構造器
    public Parent() {
        System.out.println("父類--構造器");
    }
}//如果你想把這兩個類放在同一個文件且名字起為SubClass, 父類前不能加public
public class SubClass extends Parent {　
    // 靜態變量
    public static String s_StaticField = "子類--靜態變量";
    // 變量
    public String s_Field = "子類--變量";
    // 靜態初始化塊
    static {
        System.out.println(s_StaticField);
        System.out.println("子類--靜態初始化塊");
    }
    // 初始化塊
    {
        System.out.println(s_Field);
        System.out.println("子類--初始化塊");
    }
    // 構造器
    public SubClass() {
        System.out.println("子類--構造器");
    }
    // 程序入口
    public static void main(String[] args) {
        new SubClass();
    }
}

結果顯示：
父類--靜態變量
父類--靜態初始化塊
子類--靜態變量
子類--靜態初始化塊
父類--變量
父類--初始化塊
父類--構造器
子類--變量
子類--初始化塊
子類--構造器

規則2（靜態變量和靜態初始化塊）：
靜態變量和靜態初始化塊是依照他們在類中的定義順序進行初始化的。同樣，變量和初
始化塊也遵循這個規律。
代碼如下：

public class testOrder {
    // 靜態變量
    public static TestA a = new TestA();
    public TestC c = new TestC();
    // 靜態變量
    public static TestB b = new TestB();
    public testOrder(){
        System.out.println("in constract");
    }
    // 靜態初始化塊
    static {
        System.out.println("靜態初始化塊");
    }
    public static void main(String[] args) {
        new testOrder();
    }
}
class TestA {
    public TestA() {
        System.out.println("Test--A");
    }
}
class TestB {
    public TestB() {
        System.out.println("Test--B");
    }
}
class TestC {
    public TestC() {
        System.out.println("Test--C");
    }
}

結果顯示：
Test--A
Test--B
靜態初始化塊
Test--C
in constract

個人總結：
先靜後動，先父後子，從上到下，先變量後構造