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。

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

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