30

对于以下代码：

public class StaticFinal
{
    private final static int i ;
    public StaticFinal()
    {}
}

我得到编译时错误：

StaticFinal.java:7: variable i might not have been initialized
        {}
         ^
1 error

这符合JLS8.3.1.2，其中说：

如果在其中声明它的类的静态初始化程序（第 8.7 节）没有明确地分配（第 16.8 节）一个空白 final（第 4.12.4 节）类变量，则这是一个编译时错误。

所以，上面的错误就完全明白了。
但现在考虑以下几点：

public class StaticFinal
{
    private final static int i ;
    public StaticFinal()throws InstantiationException
    {
        throw new InstantiationException("Can't instantiate"); // Don't let the constructor to complete.
    }
}

在这里，构造函数永远不会完成，因为InstantiationException在构造函数的中间被抛出。这段代码编译得很好！！
为什么？为什么这段代码没有显示关于final变量非初始化的编译时错误i？


编辑
我正在使用javac 1.6.0_25命令提示符编译它（不使用任何 IDE）

4

4 回答 4

3

有趣的是，无论字段是否被标记，代码都会编译static- 在 IntelliJ 中，它会抱怨（但编译）静态字段，而不是对非静态字段说一句话。

你是对的，JLS §8.1.3.2 有一些关于 [静态] 最终字段的规则。但是，这里还有一些其他关于 final 字段的规则，它们来自 Java 语言规范§4.12.4 - 它指定了final字段的编译语义。

但在我们进入那个蜡球之前，我们需要确定当我们看到时会发生什么——这是§14.18throws给我们的，强调我的：

throw 语句会引发异常（§11）。结果是立即转移控制（第 11.3 节），可能会退出多个语句和多个构造函数、实例初始化程序、静态初始化程序和字段初始化程序评估以及方法调用，直到找到捕获抛出值的 try 语句（第 14.20 节）。如果没有找到这样的 try 语句，则在为线程所属的线程组调用 uncaughtException 方法后终止执行 throw 的线程（第 17 节）的执行（第 11.3 节）。

通俗地说——在运行时，如果我们遇到一个throws语句，它可以中断构造函数的执行（正式地，“突然完成”），导致对象不能被构造，或者构造成不完整的状态。这可能是一个安全漏洞，具体取决于平台和构造函数的部分完整性。

§4.5 给出的 JVM 期望的是，具有ACC_FINALset的字段在构造对象后永远不会设置其值：

宣布终局；从未直接分配给对象构造后（JLS §17.5）。

所以，我们有点麻烦 - 我们希望在运行时出现这种行为，但在编译时不会。为什么 IntelliJ 会在我static在那个领域有小题大做，而不是在我没有的时候呢？

首先，回到- 如果不满足这三个部分之一，throws则该语句只有一个编译时错误：

  • 抛出的表达式未经检查或为空，
  • 你try是catch例外，你正在catch使用正确的类型，或者
  • 根据 §8.4.6 和 §8.8.5，被抛出的表达式实际上是可以抛出的。

所以用 a 编译构造函数throws是合法的。碰巧的是，在运行时，它总是会突然完成。

如果一个 throw 语句包含在构造函数声明中，但它的值没有被包含它的一些 try 语句捕获，那么调用构造函数的类实例创建表达式将由于 throw 突然完成（第 15.9.4 节）。

现在，进入那个空白final字段。他们有一个奇怪的部分 - 他们的分配只在构造函数结束后才重要，强调他们的。

必须在声明它的类的每个构造函数（第 8.8 节）的末尾明确分配一个空白的最终实例变量（第 16.9 节）；否则会发生编译时错误。

如果我们永远不会到达构造函数的末尾怎么办？

第一个程序：一个字段的正常实例化static final，反编译：

// class version 51.0 (51)
// access flags 0x21
public class com/stackoverflow/sandbox/DecompileThis {

    // compiled from: DecompileThis.java

    // access flags 0x1A
    private final static I i = 10

    // access flags 0x1
    public <init>()V
            L0
    LINENUMBER 7 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
            L1
    LINENUMBER 9 L1
            RETURN // <- Pay close attention here.
    L2
    LOCALVARIABLE this Lcom/stackoverflow/sandbox/DecompileThis; L0 L2 0
    MAXSTACK = 1
    MAXLOCALS = 1
}

观察我们RETURN在成功调用我们的<init>. 有道理，而且完全合法。

第二个程序：抛出构造函数和空白static final字段，反编译：

// class version 51.0 (51)
// access flags 0x21
public class com/stackoverflow/sandbox/DecompileThis {

  // compiled from: DecompileThis.java

  // access flags 0x1A
  private final static I i

  // access flags 0x1
  public <init>()V throws java/lang/InstantiationException 
   L0
    LINENUMBER 7 L0
    ALOAD 0
    INVOKESPECIAL java/lang/Object.<init> ()V
   L1
    LINENUMBER 8 L1
    NEW java/lang/InstantiationException
    DUP
    LDC "Nothin' doin'."
    INVOKESPECIAL java/lang/InstantiationException.<init> (Ljava/lang/String;)V
    ATHROW // <-- Eeek, where'd my RETURN instruction go?!
   L2
    LOCALVARIABLE this Lcom/stackoverflow/sandbox/DecompileThis; L0 L2 0
    MAXSTACK = 3
    MAXLOCALS = 1
}

的规则ATHROW表明引用被弹出，并且如果那里有异常处理程序，它将包含处理异常的指令的地址。否则，它会从堆栈中移除。

我们从不明确地return，因此暗示我们永远不会完成对象的构造。因此，可以认为该对象处于不稳定的半初始化状态，同时遵守编译时规则——也就是说，所有语句都是可访问的。

在静态字段的情况下，由于它不被视为实例变量，而是类变量，因此允许这种调用似乎是错误的。可能值得提交一个错误。

回想一下，它在上下文中确实有一定的意义，因为 Java 中的以下声明是合法的，并且方法体与构造函数体是一致的：

public boolean trueOrDie(int val) {
    if(val > 0) {
        return true;
    } else {
        throw new IllegalStateException("Non-natural number!?");
    }
}
于 2013-07-15T06:49:58.957 回答
1

正如我在这里所理解的那样，我们都是开发人员，所以我相信我们不会在我们中间找到真正的回应......这件事与编译器内部有关......我认为是一个错误，或者至少是一个不受欢迎的行为。

不包括具有某种增量编译器（因此能够立即检测到问题）的 Eclipse，命令行 javac 执行一次性编译。现在，第一个片段 

public class StaticFinal {
    private final static int i ;
}

这与具有空构造函数（如第一个示例中）基本相同，抛出编译时错误，这很好，因为尊重规范。

在第二个片段中，我认为编译器中有一个错误；似乎编译器会根据构造函数的操作做出一些决定。如果您尝试编译这个，这一点会更加明显，

public class StaticFinal
{
    private final static int i ;

    public StaticFinal() 
    {
        throw new RuntimeException("Can't instantiate"); 
    }
}

这比你的例子更奇怪，因为未经检查的异常没有在方法签名中声明，并且只会在运行时发现（至少这是我在阅读这篇文章之前的想法）。

观察我可以说的行为（但根据规范是错误的）。

对于静态最终变量，编译器会尝试查看它们是否被显式初始化，或者在静态初始化程序块中初始化，但是，出于某种奇怪的原因，它也在构造函数中寻找一些东西：

  • 如果它们在构造函数中被初始化，编译器会产生错误（你不能为最终的静态变量赋值）
  • 如果构造函数为空，则编译器将产生错误（如果编译第一个示例，即具有显式零参数构造函数的示例，编译器将中断指示构造函数的右括号作为错误行）。
  • 如果由于抛出异常而导致构造函数未完成而无法实例化类（例如，如果您编写 System.exit(1) 而不是抛出异常，则不是这样......它不会编译！），然后将默认值分配给静态变量（！）
于 2013-06-29T09:04:58.933 回答
0

添加 main 方法后，使代码打印i。代码打印值 0。这意味着 java 编译器自动将 i 初始化为值 0。我在 IntelliJ 中编写了它，并且必须禁用代码检查才能构建代码。否则它不会让我在抛出异常之前给我同样的错误。

JAVA代码：未初始化

public class StaticFinal {
    private final static int i;
    public StaticFinal(){
        throw new InstantiationError("Can't instantiate!");
    }

    public static void main(String args[]) {
        System.out.print(i);
    }

}

反编译

完全相同的

JAVA代码：初始化

public class StaticFinal {
    private final static int i = 0;
    public StaticFinal(){
        throw new InstantiationError("Can't instantiate!");
    }

    public static void main(String args[]) {
        System.out.print(StaticFinal.i);
    }

}

反编译

public class StaticFinal
{

    public StaticFinal()
    {
        throw new InstantiationError("Can't instantiate!");
    }

    public static void main(String args[])
    {
        System.out.print(0);
    }

    private static final int i = 0;
}

反编译代码后发现并非如此。因为反编译的代码和原来的代码是一样的。唯一的另一种可能性是初始化是通过 Java 虚拟机完成的。我所做的最后更改足以证明情况确实如此。

不得不说你发现了这一点。

相关问题： 这里

于 2013-06-29T08:29:24.750 回答
-2

我想说这仅仅是因为当你添加 时Throws，你基本上是在处理错误，所以编译器会“哦，好吧，他可能知道他当时在做什么”。毕竟，它仍然会产生运行时错误。

于 2013-07-04T14:04:20.513 回答