通过反射更改私有最终字段

Question

class WithPrivateFinalField {
    private final String s = "I’m totally safe";
    public String toString() {
        return "s = " + s;
    }
}
WithPrivateFinalField pf = new WithPrivateFinalField();
System.out.println(pf);
Field f = pf.getClass().getDeclaredField("s");
f.setAccessible(true);
System.out.println("f.get(pf): " + f.get(pf));
f.set(pf, "No, you’re not!");
System.out.println(pf);
System.out.println(f.get(pf));

输出：

s = I’m totally safe
f.get(pf): I’m totally safe
s = I’m totally safe
No, you’re not!

为什么会这样，你能解释一下吗？第一个打印告诉我们私有“s”字段没有改变，正如我所期望的那样。但是，如果我们通过反射获取该字段，则第二个打印显示它已更新。

Answer 1

这个答案对于这个主题来说非常详尽。

JLS 17.5.3 最终字段的后续修改

即便如此，仍然存在许多并发症。如果最后一个字段是
在字段声明中初始化为编译时常量，
可能无法观察到最终字段的更改，因为该字段的使用
Final 字段在编译时被替换为编译时
常数。

但是，如果您仔细阅读上面的段落，您可能会在这里找到一种方法（在构造函数中而不是在字段定义中设置 private final 字段）：

import java.lang.reflect.Field;


public class Test {

  public static void main(String[] args) throws Exception {
    WithPrivateFinalField pf = new WithPrivateFinalField();
    System.out.println(pf);
    Field f = pf.getClass().getDeclaredField("s");
    f.setAccessible(true);
    System.out.println("f.get(pf): " + f.get(pf));
    f.set(pf, "No, you’re not!");
    System.out.println(pf);
    System.out.println("f.get(pf): " + f.get(pf));
  }

  private static class WithPrivateFinalField {
    private final String s;

    public WithPrivateFinalField() {
      this.s = "I’m totally safe";
    }
    public String toString() {
      return "s = " + s;
    }
  }

}

输出如下：

s = I’m totally safe
f.get(pf): I’m totally safe
s = No, you’re not!
f.get(pf): No, you’re not!

Hope这有点帮助。

Answer 2

这

class WithPrivateFinalField {
    private final String s = "I’m totally safe";
    public String toString() {
        return "s = " + s;
    }  
} 

实际上是这样编译的：

class WithPrivateFinalField {
    private final String s = "I’m totally safe";
    public String toString() {
        return "s = I’m totally safe";
    }  
}

也就是说，编译时常量被内联。请参阅这个问题。避免内联的最简单方法是像这样声明 String：

private final String s = "I’m totally safe".intern();

对于其他类型，一个简单的方法调用即可解决问题：

private final int integerConstant = identity(42);
private static int identity(int number) {
    return number;
}

Answer 3

下面是 WithPrivateFinalField 类文件的反编译（为了简单起见，我将其放在一个单独的类中）：

  WithPrivateFinalField();
     0  aload_0 [this]
     1  invokespecial java.lang.Object() [13]
     4  aload_0 [this]
     5  ldc <String "I’m totally safe"> [8]
     7  putfield WithPrivateFinalField.s : java.lang.String [15]
    10  return
      Line numbers:
        [pc: 0, line: 2]
        [pc: 4, line: 3]
        [pc: 10, line: 2]
      Local variable table:
        [pc: 0, pc: 11] local: this index: 0 type: WithPrivateFinalField

  // Method descriptor #22 ()Ljava/lang/String;
  // Stack: 1, Locals: 1
  public java.lang.String toString();
    0  ldc <String "s = I’m totally safe"> [23]
    2  areturn
      Line numbers:
        [pc: 0, line: 6]
      Local variable table:
        [pc: 0, pc: 3] local: this index: 0 type: WithPrivateFinalField

注意在 toString() 方法中，地址 0 处使用的常量 [0 ldc ; [23]] 显示编译器已经提前将字符串文字 "s = " 和私有最终字段 " I'm Excellent safe" 连接在一起，存储它。无论实例变量 s 如何变化，toString() 方法都将始终返回 "s = I'm Excellent safe"。

Answer 4

作为 final，编译器希望该值不会更改，因此它可能将字符串直接硬编码到 toString 方法中。