Java類初始化順序

一、靜態變數與靜態初始化塊

在Java中，靜態變數和靜態初始化塊的初始化優先順序高於普通變數和代碼塊，它們在類被載入時就被初始化。

public class StaticExample {
    static int s = 1;
    static{
        s++;
    }
    public static void main(String[] args){
        System.out.println(s); //輸出結果：2
    }
}

在上述代碼中，當類被載入時，靜態變數s會被初始化為1，接著靜態初始化塊中的代碼會被執行，將s的值加1，因此輸出結果為2。

靜態變數和靜態初始化塊的初始化順序取決於它們在代碼中的出現順序。

public class StaticExample {
    static int s = 1;
    static{
        System.out.println(s); //輸出結果：1
    }
    static int t = 2;
    static{
        System.out.println(s); //輸出結果：1
        System.out.println(t); //輸出結果：2
    }
}

在上述代碼中，當類被載入時，s先被初始化為1，然後執行靜態初始化塊中的代碼。接著t被初始化為2，最後又執行靜態初始化塊中的代碼。

二、成員變數與初始化塊

Java中成員變數可以在聲明時進行初始化，也可以在初始化塊中進行初始化。

public class FieldExample {
    int x = 1;
    {
        x++;
    }
    int y = 2;
    {
        System.out.println(x); //輸出結果：2
        System.out.println(y); //輸出結果：2
    }
}

在上述代碼中，當類被實例化時，成員變數x先被初始化為1，然後執行初始化塊中的代碼，將x的值加1。接著y被初始化為2，最後又執行初始化塊中的代碼。

成員變數和初始化塊的初始化順序取決於它們在代碼中的出現順序。

三、構造方法

構造方法在類被實例化時被調用，可以對成員變數進行初始化操作。

public class ConstructorExample {
    int x;
    int y;
    int z;
    public ConstructorExample(){
        x++;
        y = 2;
    }
    public ConstructorExample(int z){
        x = 2;
        y++;
        this.z = z;
    }
    public static void main(String[] args){
        ConstructorExample ce1 = new ConstructorExample();
        System.out.println(ce1.x); //輸出結果：1
        System.out.println(ce1.y); //輸出結果：2
        System.out.println(ce1.z); //輸出結果：0
        ConstructorExample ce2 = new ConstructorExample(3);
        System.out.println(ce2.x); //輸出結果：2
        System.out.println(ce2.y); //輸出結果：1
        System.out.println(ce2.z); //輸出結果：3
    }
}

在上述代碼中，構造方法可以有不同的參數，根據參數的不同來對成員變數進行不同的初始化操作。

構造方法的初始化順序是先執行父類的構造方法，再執行自己的構造方法，最後執行成員變數和初始化塊。

四、繼承中的初始化順序

在繼承關係中，子類的初始化順序依賴於它父類的初始化順序。

public class Parent {
    static int s = 1;
    int x = 1;
    {
        x++;
    }
    public Parent(){
        x++;
    }
    static{
        s++;
    }
}
public class Child extends Parent {
    static int t = 2;
    int y = 2;
    {
        y++;
    }
    public Child(){
        y++;
    }
    static{
        t++;
    }
    public static void main(String[] args){
        System.out.println(s); //輸出結果：2
        System.out.println(t); //輸出結果：3
        Child c = new Child();
        System.out.println(c.x); //輸出結果：3
        System.out.println(c.y); //輸出結果：4
    }
}

在上述代碼中，當類被載入時，先執行Parent類的靜態塊並將s的值加1，接著執行Child類的靜態塊並將t的值加1。

在實例化時，先執行父類的構造方法，父類的成員變數和初始化塊被初始化，然後執行子類的構造方法，子類的成員變數和初始化塊被初始化。

成員變數和初始化塊的初始化順序取決於它們在代碼中的出現順序。同時，當子類的構造方法調用父類的構造方法時，父類的構造方法會先被執行。