Question

我有这样的代码：

public class App {
    private final String some;
    public App(){
        some = "old";
    }
    public static void main(String... args) throws NoSuchFieldException, IllegalAccessException {
        App a = new App();
        a.magic();
        System.out.println(a.some);

    }
    private void magic() throws NoSuchFieldException, IllegalAccessException {
        Field field = this.getClass().getDeclaredField("some");
        field.setAccessible(true);
        Field modifiersField = Field.class.getDeclaredField("modifiers");
        modifiersField.setAccessible(true);
        modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);
        field.set(this, "new");
        String someDuplicate = (String) field.get(this);
        System.out.println(someDuplicate);
    }
}

此输出将为

new 
new

但如果我将变量初始化更改为：

private final String some = "old";

输出将是

new
old

似乎内联初始化会导致最终非静态字段的静态行为

我无法找到任何停靠此行为的引用，可能有一些合理的解释。

顺便说一下，init字段的这种方式会导致类似构造函数初始化的行为：

{
    some = "old";
}

Answer 1

javac执行常量内联。当你有一个代码，如

class A {
    final String text = "Hello";

    public static void main(String... args) {
        System.out.println(new A().text);
    }
}

javac可以内联常量，因为它在编译时已知。这使得更改基础字段对其内联的位置没有影响。

通过将值移动到构造函数，在编译时不再知道它。

转储main方法的字节代码，您可以看到它没有读取字段，而是LDC加载常量"Hello"

  public static varargs main([Ljava/lang/String;)V
   L0
    LINENUMBER 5 L0
    GETSTATIC java/lang/System.out : Ljava/io/PrintStream;
    NEW A
    DUP
    INVOKESPECIAL A.<init> ()V
    INVOKEVIRTUAL java/lang/Object.getClass ()Ljava/lang/Class;
    POP
    LDC "Hello"
    INVOKEVIRTUAL java/io/PrintStream.println (Ljava/lang/String;)V
   L1
    LINENUMBER 6 L1
    RETURN
   L2
    LOCALVARIABLE args [Ljava/lang/String; L0 L2 0
    MAXSTACK = 3
    MAXLOCALS = 1

我觉得有趣的是，它仍然会创建A并使用.getClass()将其检查为空，因此它的优化只会到目前为止。

BTW您可以在不使用包装方法的构造函数/初始化块的情况下解决此问题。

class A {
    final String text = dynamic("Hello");
    // or final String text = String.valueOf("Hello");

    public static void main(String... args) {
        System.out.println(new A().text);
    }

    static <T> T dynamic(T t) {
        return t;
    }
}

或在编译时无法确定的任何表达式。

最后以某种方式导致静态行为

1 个答案: