Java 中的静态/实例初始化程序块按什么顺序运行？

Question

假设一个项目包含多个类，每个类都有一个静态初始化块。这些块按什么顺序运行？我知道在一个类中，这些块按照它们在代码中出现的顺序运行。我读到它在各个类中都是相同的，但我编写的一些示例代码与此不同。我使用了这段代码：

package pkg;

public class LoadTest {
    public static void main(String[] args) {
        System.out.println("START");
        new Child();
        System.out.println("END");
    }
}

class Parent extends Grandparent {
    // Instance init block
    {
        System.out.println("instance - parent");
    }

    // Constructor
    public Parent() {
        System.out.println("constructor - parent");
    }

    // Static init block
    static {
        System.out.println("static - parent");
    }
}

class Grandparent {
    // Static init block
    static {
        System.out.println("static - grandparent");
    }

    // Instance init block
    {
        System.out.println("instance - grandparent");
    }

    // Constructor
    public Grandparent() {
        System.out.println("constructor - grandparent");
    }
}

class Child extends Parent {
    // Constructor
    public Child() {
        System.out.println("constructor - child");
    }

    // Static init block
    static {
        System.out.println("static - child");
    }

    // Instance init block
    {
        System.out.println("instance - child");
    }
}

并得到了这个输出：

开始
静态 - 祖父母
静态 - 父级
静态 - 子
实例 - 祖父母
构造函数 - 祖父母
实例 - 父级
构造函数 - 父级
实例 - 子
构造函数 - 子
结束

的答案是，父母的块在孩子的块之前运行，但这可能只是巧合，如果两个类不在同一层次结构中，则没有帮助。

编辑：

我通过将其附加到 LoadTest.java 来修改我的示例代码：

class IAmAClassThatIsNeverUsed {
    // Constructor
    public IAmAClassThatIsNeverUsed() {
        System.out.println("constructor - IAACTINU");
    }

    // Instance init block
    {
        System.out.println("instance - IAACTINU");
    }

    // Static init block
    static {
        System.out.println("static - IAACTINU");
    }
}

正如类名称所暗示的那样，我从未在任何地方引用过新类。新程序产生与旧程序相同的输出。

Answer 1

请参阅 JLS 版本的第 12.4 和 12.5 节8，他们详细介绍了所有这些（12.4 为静态变量，12.5 为实例变量）。

对于静态初始化（第 12.4 节）：

类或接口类型 T 将在第一次出现以下任一情况之前立即进行初始化：

• T 是一个类并且创建了 T 的实例。
• T 是一个类，并且调用 T 声明的静态方法。
• 由 T 声明的静态字段被赋值。
• 使用 T 声明的静态字段，并且该字段不是常量变量（第 4.12.4 节）。
• T 是顶级类（第 7.6 节），并且执行词法嵌套在 T（第 8.1.3 节）内的断言语句（第 14.10 节）。

（以及一些狡猾的词句）

Answer 2

首次访问类时，类的静态初始化程序将运行，以创建实例或访问静态方法或字段。

因此，对于多个类，这完全取决于运行来导致加载这些类的代码。

Answer 3

基思和克里斯的答案都很好，我只是为我的具体问题添加一些更多细节。

静态初始化块按照其类初始化的顺序运行。那么，那是什么顺序呢？根据 JLS 12.4.1：

类或接口类型 T 将在第一次出现以下任一情况之前立即初始化：

• T 是一个类，并且创建了 T 的实例。
• T 是一个类，并且调用 T 声明的静态方法。
• 分配了 T 声明的静态字段。
• 使用 T 声明的静态字段，并且该字段不是常量变量（第 4.12.4 节）。
• T 是顶级类，并且执行词法嵌套在 T 中的断言语句（第 14.10 节）。

调用类 Class 和包 java.lang.reflect 中的某些反射方法也会导致类或接口初始化。在任何其他情况下，类或接口都不会被初始化。

为了说明这一点，以下是示例中发生的情况的演练：

1. Enter main
2. Print "START"
3. 尝试创建 Child 的第一个实例，这需要初始化 Child
4. 尝试初始化 Child 会导致 Parent 的初始化
5. 尝试初始化 Parent 会导致 Grandparent 的初始化
6. 在 Grandparent 初始化开始时，运行 Grandparent 的静态初始化块
7. 从技术上讲，对象拥有最后发言权在初始化链中，由于是 Grandparent 的 Parent，但它没有任何贡献
8. 在 Grandparent 的静态初始化块结束后，程序回退到 Parent 的静态初始化块
9. 在 Parent 的静态初始化之后块结束，程序回退到 Child 的静态初始化块
10. 此时，Child 已初始化，因此其构造函数可以继续
11. 由于 IAmAClassThatIsNeverUsed 从未被引用，因此它的任何代码都不会运行，包括静态初始值设定项块
12. 本演练的其余部分不涉及静态初始值设定项，只是为了完整性而包含
13. 在内
14. 。构造函数）
15. 祖父母的构造函数执行相同的操作，但没有任何效果（同样，对象没有任何贡献）
16. 祖父母的构造函数调用 super() 后立即出现祖父母的实例初始化程序块
17. 祖父母的构造函数的其余部分运行并且构造函数终止
18. 程序回退在对 super()（即祖父的构造函数）的调用解析之后，立即返回到父级的
19. 构造函数。如上所述，父级的实例初始值设定项执行其操作，并且其构造函数完成。
20. 类似地，程序返回并完成子级的构造函数
21. 此时，该对象已完成已实例化
22. 打印“END”
23. 正常终止

Answer 4

有一种情况不会调用静态块。

class Super {
    public static int i=10;
}
class Sub extends Super {
    static {
        system.out.println("Static block called");
    }
}
class Test {
    public static void main (String [] args) {
        system.out.println(Sub.i);
    } 
}

上面的代码输出 10

---

来自“编辑器”的更新

对此的技术解释位于 JLS 12.4.1

“对静态字段（§8.3.1.1）的引用只会导致实际声明它的类或接口的初始化，即使它可能通过子类、子接口或子接口的名称来引用。实现接口的类。”

直观的解释是 Super.i 和 Sub.i 实际上是同一个变量，而 Sub 中什么都没有> 实际上需要初始化 Super.i 才能获得正确的值。

^{（如果 Super.i 的初始化表达式引用 Sub 类，情况会有所不同。但是这样你就会在初始化顺序中出现一个循环。仔细观察阅读 JLS 12.4.1 和 JLS 12.4.2 解释说这是允许的，并允许您准确地计算出实践中会发生什么。）}

Answer 5

类的初始化包括执行其静态初始化程序和类中声明的静态字段（类变量）的初始化程序。

接口的初始化包括执行接口中声明的字段（常量）的初始化程序。

在初始化类之前，必须初始化其直接超类，但不初始化该类实现的接口。同样，接口初始化之前不会初始化接口的超级接口。

Answer 6

您可以在同一个类中拥有多个静态和实例初始化程序，因此

• 静态初始化程序按照声明的文本顺序调用（来自 12.4.2）
• 实例初始值设定项按其声明的文本顺序调用（来自 12.5)

每个都像单个块一样执行。

Answer 7

class A {
  public A() { 
    // 2
  }
}

class B extends A{
  static char x = 'x'; // 0
  char y = 'y'; // 3
  public B() { 
    // 4
  }

  public static void main(String[] args) {
    new B(); // 1
  }
}

注释中的数字表示评估顺序，越小越早。

如示例所示，

1. 静态变量
2. 主构造函数
3. 的
4. 超类实例变量
5. 构造函数

Answer 8

http://docs.oracle.com/javase/tutorial/java/javaOO /initial.html

请检查java文档。

然后明确提到，无论静态块有多少，它们都会按照它们出现的顺序作为单个块执行，

所以，

我的理解是java正在将您的代码视为

static{
i=1;
i=2;
}

static int i;

这就是为什么你得到输出 2

希望这有帮助