编译时在代码中替换Java静态最终值？

Question

在java中，假设我有以下内容

==fileA.java==
class A
{  
    public static final int SIZE = 100;
}  

然后在另一个文件中我使用这个值

==fileB.java==  
import A;
class b
{
      Object[] temp = new Object[A.SIZE];
}

当这个被编译时，SIZE会被值100替换，这样如果我要替换FileA.jar而不是FileB .jar，对象数组会获得新值还是会被硬编码为 100，因为这是最初构建时的值？

Answer 1

是的，Java 编译器确实将示例中的静态常量值（如 SIZE）替换为其文字值。

因此，如果您稍后更改类 A 中的 SIZE 但不重新编译类 b，您仍然会在类中看到旧值b。您可以轻松地进行测试：

文件 A.java

public class A {
    public static final int VALUE = 200;
}

文件 B.java

public class B {
    public static void main(String[] args) {
        System.out.println(A.VALUE);
    }
}

编译 A.java 和 B.java。现在运行：java B

更改 A.java 中的值。重新编译A.java，但不重新编译B.java。再次运行，您将看到打印旧值。

Answer 2

您可以通过执行以下操作来防止常量被编译到 B 中

class A
{  
    public static final int SIZE;

    static 
    {
        SIZE = 100;
    }
}  

Answer 3

证明该行为的另一种方法是查看生成的字节码。当常数“小”时（大概< 128）：（

public B();
  Code:
   0:   aload_0
   1:   invokespecial   #10; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   bipush  42
   7:   anewarray       #3; //class java/lang/Object
   10:  putfield        #12; //Field temp:[Ljava/lang/Object;
   13:  return

}

我使用 42 而不是 100，所以它更突出）。在这种情况下，它显然被替换在字节码中。但是，假设常数“更大”。然后你会得到如下所示的字节码：

public B();
  Code:
   0:   aload_0
   1:   invokespecial   #10; //Method java/lang/Object."<init>":()V
   4:   aload_0
   5:   ldc     #12; //int 86753098
   7:   anewarray       #3; //class java/lang/Object
   10:  putfield        #13; //Field temp:[Ljava/lang/Object;
   13:  return

当它更大时，使用操作码“ldc”，根据 JVM 文档 “一个无符号字节，必须是当前类的运行时常量池的有效索引”。

在任何一种情况下，常量都会嵌入到 B 中。我想，由于在操作码中您只能访问当前类运行时常量池，因此将常量写入类文件的决定与实现无关（但我不这样做）事实上我不知道）。

Answer 4

哇——你每天都会学到新东西！

摘自 Java 规范...

注意：如果是基本类型或者字符串
被定义为一个常数，其值
在编译时已知，编译器
到处替换常量名称
在代码中及其值。这是
称为编译时常量。如果
外部常数的值
世界发生变化（例如，如果
立法规定 pi 实际上应该是
3.975），您将需要重新编译使用此常量的所有类以获得
当前值。

Answer 5

这里的重要概念是，static final 字段是用 JLS 中定义的编译时常量初始化的。使用非常量初始值设定项（或非static 或非final）并且它不会被复制：（

public static final int SIZE = null!=null?0: 100;

null 不是 *compile -时间常数`。）

Answer 6

事实上，我不久前就遇到过这种奇怪的情况。

这将直接将“100”编译成b类。如果你只是重新编译类A，这不会更新类B中的值。

最重要的是，编译器可能不会注意到重新编译类b（当时我正在编译单个目录，类B位于单独的目录中并编译a的目录没有触发B的编译）

Answer 7

作为优化，编译器将内联该 final 变量。

所以在编译时它看起来像。

class b
{
      Object[] temp = new Object[100];
}

Answer 8

需要注意的一件事是：静态最终值在编译时已知
如果在编译时未知该值，编译器不会将代码中各处的常量名称替换为其值。

  public class TestA {
      // public static final int value = 200;
      public static final int value = getValue();
      public static int getValue() {
        return 100;
      }
  }

public class TestB {
    public static void main(String[] args) {
        System.out.println(TestA.value);
    }
}

首先编译TestA和TestB，运行TestB

然后将TestA.getValue()更改为返回200，编译TestA，运行TestB，TestB将获得新值
在此处输入图片说明

Answer 9

有一个例外：-

如果静态最终字段在编译时为 null，则它不会被替换为 null （实际上是它的值）

A.java

class A{
     public static final String constantString = null;
}

B.java

class B{
     public static void main(String... aa){
         System.out.println(A.constantString);
     }
}

编译A.java和B.java并运行java B

<块引用>

输出将为null

---

现在使用以下代码更新A.java并仅编译此类。

class A{
     public static final String constantString = "Omg! picking updated value without re-compilation";
}

现在运行java B

<块引用>

输出将是天啊！选择更新的值而不重新编译

Answer 10

Java 确实会优化这些类型的值，但前提是它们属于同一类。在这种情况下，由于您正在考虑的使用情况，JVM 会查看 A.SIZE 而不是对其进行优化。