Java 程序初始化顺序

Java 中的类有一个初始化顺序，这决定了类中的字段和静态代码块的初始化顺序。要理解这个初始化顺序，需要了解以下方法和静态变量的初始化规则，以及如何保持正确的初始化顺序。

1. 静态变量初始化

在 Java 类中，静态变量是在类被加载时初始化的。这意味着当 JVM 加载类时，会先初始化静态变量，然后才会初始化普通变量。

以下是初始化静态变量的示例代码：

public class MyClass {

    //静态变量声明
    static int myInt = 5;

    // 静态代码块中初始化静态变量
    static {
        myInt = 10;
    }
}

2. 静态代码块

在类加载时，Java 还允许使用静态代码块初始化静态变量，如上述示例代码所示。这些代码块会在静态变量之前执行。

以下是使用静态代码块进行初始化的代码示例：

public class MyClass {

    static int myInt;

    static {
        myInt = 10;
    }

    //此处使用 myInt 变量
}

3. 父类初始化

在子类中调用父类的构造函数之前，父类必须被先初始化。这意味着父类中的静态变量、静态代码块、以及构造函数都必须在子类的成员变量和构造函数之前初始化。

以下是父类和子类的示例代码：

public class ParentClass {

    static int parentInt = 10;

    static {
        System.out.println("ParentClass static block");
    }

    ParentClass() {
        System.out.println("ParentClass constructor");
    }
}

public class ChildClass extends ParentClass {

    static int childInt = 20;

    static {
        System.out.println("ChildClass static block");
    }

    ChildClass() {
        System.out.println("ChildClass constructor");
    }

    public static void main(String[] args) {
        ChildClass child = new ChildClass();
    }
}

当运行 ChildClass 的 main 方法时，由于继承关系，ParentClass 将首先被加载和初始化。因此将打印以下输出：

ParentClass static block
ChildClass static block
ParentClass constructor
ChildClass constructor

4. 示例说明

以下示例解释了如何使用静态代码块和静态变量进行初始化。

public class MyClass {

    //声明静态变量
    static int myInt;

    static {
        myInt = 20;
        System.out.println("Static block: " + myInt);
    }

    public static void main(String[] args) {
        System.out.println("Main method: " + myInt);
    }
}

输出：

Static block: 20
Main method: 20

在 MyClass 类被加载时，myInt 变量首先被声明，然后静态代码块将其初始化为 20。main 方法随后被调用，打印 myInt 的值为 20。

以下示例解释了如何使用父类和子类的构造函数和静态变量进行初始化。

public class ParentClass {

    //静态变量
    static int parentInt = 10;

    static {
        System.out.println("Parent Class Static block");
        System.out.println("Static variable parentInt = "+parentInt);
    }

    ParentClass() {
        System.out.println("Parent Class constructor");
    }
}

public class ChildClass extends ParentClass {

    //静态变量
    static int childInt = 20;

    static {
        System.out.println("Child Class Static block");
        System.out.println("Static variable childInt = "+childInt);
    }

    ChildClass() {
        super();
        System.out.println("Child Class constructor");
    }

    public static void main(String[] args) {
        ChildClass child = new ChildClass();
    }
}

输出：

Parent Class Static block
Static variable parentInt = 10
Child Class Static block
Static variable childInt = 20
Parent Class constructor
Child Class constructor

在 main 方法运行时，ChildClass 首先被加载。由于继承关系，ParentClass 首先进行初始化，所以将打印出：

Parent Class Static block
Static variable parentInt = 10

然后会初始化 ChildClass，并打印输出：

Child Class Static block
Static variable childInt = 20

最后，将打印出每个类的构造函数调用。