Java 中使用大括号的奇怪行为

Question

当我运行以下代码时：

public class Test {

  Test(){
    System.out.println("1");
  }

  {
    System.out.println("2");
  }

  static {
    System.out.println("3");
  }

  public static void main(String args[]) {
    new Test();
  }
}

我希望按此顺序获得输出：

1
2
3

但我得到的是相反的顺序：

3
2
1

谁能解释为什么它以相反的顺序输出？

================

另外，当我创建多个 Test 实例时：

new Test();
new Test();
new Test();
new Test();

第一次仅执行静态块。

Answer 1

这完全取决于初始化语句的执行顺序。您的测试表明这个顺序是：

1. 静态初始化块
2. 实例初始化块
3. 构造函数

编辑

感谢您的评论，现在我可以引用 JVM 规范中的相应部分。 这里详细的初始化过程。

Answer 2

3 - 是一个静态初始化程序，它在类加载时运行一次，这首先发生。

2 - 是一个初始化块，java编译器实际上会将其复制到每个构造函数中，因此如果您愿意，您可以在构造函数之间共享一些初始化。很少使用。

1 - 将在构造对象时执行，在 (3) 和 (2) 之后。

更多信息在这里

Answer 3

首先执行静态块。

然后是实例实例初始化块，

请参阅 JLS 了解实例初始化程序

{

// sop statements

}

实例初始化块中不能有 return 语句，就像构造函数一样。

Answer 4

Test(){System.out.println("1");}

    {System.out.println("2");}

    static{System.out.println("3");}

静态事物首先执行， {System.out.println("2");} 不是函数的一部分，因为它的作用域首先调用它，而 Test( ){System.out.println("1");} 最后调用，因为另外两个先调用

Answer 5

首先，类被加载到 JVM 中并进行类初始化。在此步骤中执行静态块。 “{...}”只是“static{...}”的语法等价物。由于代码中已经有一个“static{...}”块，因此“{...}”将被附加到它的后面。这就是为什么你在 2 之前打印了 3。

接下来，一旦类被加载，java.exe（我假设你从命令行执行）将找到并运行 main 方法。 main 静态方法初始化其构造函数被调用的实例，因此最后打印出“1”。

Answer 6

由于 static{} 代码在 JVM 中首次初始化类时运行（即甚至在调用 main() 之前），因此实例 {}< /code> 在实例首次初始化、构造之前调用，然后在完成所有操作后调用构造函数。

Answer 7

我在这里通过 ASM 获得了类似字节码的代码。

我认为这可以回答您的问题，解释在这种情况下创建对象时发生的情况。

public class Test {
static <clinit>() : void
GETSTATIC System.out : PrintStream
LDC "3"
INVOKEVIRTUAL PrintStream.println(String) : void
RETURN


<init>() : void
ALOAD 0: this
INVOKESPECIAL Object.<init>() : void
GETSTATIC System.out : PrintStream
LDC "2"
INVOKEVIRTUAL PrintStream.println(String) : void
GETSTATIC System.out : PrintStream
LDC "1"
INVOKEVIRTUAL PrintStream.println(String) : void
RETURN

public static main(String[]) : void
NEW Test
INVOKESPECIAL Test.<init>() : void
RETURN
}

我们可以看到LDC“3”在“clinit”中，这是一个类初始值设定项。

对象的生命周期通常是：加载类 -> 加载类 -> 加载类 -> 加载类 -> 加载类 ->链接类->类初始化->对象实例化->使用->气相色谱仪。这就是为什么 3 首先出现。由于这是在类级别，而不是对象级别，因此它将出现一次，因为类类型将被加载一次。详情请参考Java2虚拟机内部：类型的生命周期

< code>LDC "2" 和 `LDC "1" 位于构造函数“init”中。

这样做的原因是：构造函数将首先执行一些隐式指令，例如超级构造函数和类的 {} 中的代码，然后执行其构造函数中显式的代码。

这就是编译器将对 java 文件执行的操作。

Answer 8

看起来没有人说明为什么 3 只明确打印一次。所以我想补充一点，这与为什么首先打印它有关。

静态定义的代码被标记为与类的任何特定实例分开。一般来说，静态定义的代码可以被认为根本不是任何类（当然，当考虑范围时，该语句存在一些无效性）。因此，如上所述，一旦加载了类，该代码就会运行，就像在构造实例 Test() 时不会调用它一样，从而调用多次构造函数不会导致静态代码再运行。

正如上面开始的，包含 2 的括号内的代码被添加到构造函数的前面，因为它是类中所有构造函数的先决条件。您不知道 Test 的构造函数中会发生什么，但可以保证它们都以打印 2 开头。因此，这发生在任何特定构造函数中的任何内容之前，并且每次调用构造函数时都会调用。

Answer 9

完整的解释

执行的顺序是这样的，

1. 静态块
2. 实例块
3. 构造函数

函数解释

静态块将始终在开始时仅被调用一次，无论何时以任何方式访问该类，在您的这是当你运行程序时的情况。 （这就是静态块的用途）。它不依赖于实例，因此在创建新实例时不会再次调用。

然后，将为创建的每个实例调用实例初始化块，然后为创建的每个实例调用构造函数。因为两者都可以用来实例化实例。

实例初始化块实际上是否在构造函数之前调用？

编译后代码将变成，

public class Test {

  Test(){
    super();
    System.out.println("2");
    System.out.println("1");
  }


  static {
    System.out.println("3");
  }

  public static void main(String args[]) {
    new Test();
  }
}

所以你可以看到，实例块中编写的语句本身就成为构造函数的一部分。因此它在构造函数中已编写的语句之前执行。

摘自本文档

Java 编译器将初始化块复制到每个构造函数中。因此，这种方法可用于在多个构造函数之间共享代码块。