Question

让我们从一个简单的测试用例开始：

import java.lang.reflect.Field;

public class Test {
  private final int primitiveInt = 42;
  private final Integer wrappedInt = 42;
  private final String stringValue = "42";

  public int getPrimitiveInt()   { return this.primitiveInt; }
  public int getWrappedInt()     { return this.wrappedInt; }
  public String getStringValue() { return this.stringValue; }

  public void changeField(String name, Object value) throws IllegalAccessException, NoSuchFieldException {
    Field field = Test.class.getDeclaredField(name);
    field.setAccessible(true);
    field.set(this, value);
    System.out.println("reflection: " + name + " = " + field.get(this));
  }

  public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException {
    Test test = new Test();

    test.changeField("primitiveInt", 84);
    System.out.println("direct: primitiveInt = " + test.getPrimitiveInt());

    test.changeField("wrappedInt", 84);
    System.out.println("direct: wrappedInt = " + test.getWrappedInt());

    test.changeField("stringValue", "84");
    System.out.println("direct: stringValue = " + test.getStringValue());
  }
}

任何人都在乎猜测将作为输出打印的内容（显示在底部，以免立即破坏惊喜）。

问题是：

为什么原始和包装的整数表现不同？
为什么反射与直接访问会返回不同的结果？
最让我感到困惑的是 - 为什么String表现得像原始int而不像Integer？

结果（java 1.5）：

reflection: primitiveInt = 84
direct: primitiveInt = 42
reflection: wrappedInt = 84
direct: wrappedInt = 84
reflection: stringValue = 84
direct: stringValue = 42

Answer 1

编译时常量是内联的（在javac编译时）。参见JLS，特别是15.28定义了一个常量表达式，13.4.9讨论了二进制兼容性或最终字段和常量。

如果使字段为非final或分配非编译时间常量，则不会内联该值。例如：

private final String stringValue = null！= null？“”：“42”;

Answer 2

在我看来，情况更糟：一位同事指出了以下有趣的事情：

@Test public void  testInteger() throws SecurityException,  NoSuchFieldException, IllegalArgumentException, IllegalAccessException  {      
    Field value = Integer.class.getDeclaredField("value");      
    value.setAccessible(true);       
    Integer manipulatedInt = Integer.valueOf(7);      
    value.setInt(manipulatedInt, 666);       
    Integer testInt = Integer.valueOf(7);      
    System.out.println(testInt.toString());
}

通过执行此操作，您可以更改正在运行的整个JVM的行为。（当然，您只能更改-127到127之间值的值）

Answer 3

Reflection的set(..)方法适用于FieldAccessor s。

对于int，它会获得UnsafeQualifiedIntegerFieldAccessorImpl，只有当字段 readOnly时，其超类才会将static属性定义为true。 final

首先回答未提出的问题 - 这就是final毫无例外地改变的原因。

UnsafeQualifiedFieldAccessor的所有子类都使用sun.misc.Unsafe类来获取值。这些方法都是native，但它们的名称分别为getVolatileInt(..)和getInt(..)（getVolatileObject(..)和getObject(..)。上述访问者使用“易失性”版本。如果我们添加非易失性版本，会发生以下情况：

System.out.println("reflection: non-volatile primitiveInt = "
     unsafe.getInt(test, (long) unsafe.fieldOffset(getField("primitiveInt"))));

（其中unsafe通过反射实例化 - 否则不允许）（我为getObject和Integer）

致电String

这给出了一些有趣的结果：

reflection: primitiveInt = 84
direct: primitiveInt = 42
reflection: non-volatile primitiveInt = 84
reflection: wrappedInt = 84
direct: wrappedInt = 84
reflection: non-volatile wrappedInt = 84
reflection: stringValue = 84
direct: stringValue = 42
reflection: non-volatile stringValue = 84

此时我记得an article at javaspecialists.eu讨论了一个相关问题。它引用了JSR-133：

如果在字段声明中将final字段初始化为编译时常量，则可能无法观察到对final字段的更改，因为在编译时将该final字段的使用替换为编译时常量。

第9章讨论了这个问题中观察到的细节。

事实证明，这种行为并不意外，因为final字段的修改应该只在对象初始化之后才会发生。

Answer 4

这不是一个答案，但它带来了另一个混乱点：

我想知道问题是编译时评估还是反射实际上是否允许Java绕过final关键字。这是一个测试程序。我添加的是另一组getter调用，因此在每个changeField()调用之前和之后都有一个。

package com.example.gotchas;

import java.lang.reflect.Field;

public class MostlyFinal {
  private final int primitiveInt = 42;
  private final Integer wrappedInt = 42;
  private final String stringValue = "42";

  public int getPrimitiveInt()   { return this.primitiveInt; }
  public int getWrappedInt()     { return this.wrappedInt; }
  public String getStringValue() { return this.stringValue; }

  public void changeField(String name, Object value) throws IllegalAccessException, NoSuchFieldException {
    Field field = MostlyFinal.class.getDeclaredField(name);
    field.setAccessible(true);
    field.set(this, value);
    System.out.println("reflection: " + name + " = " + field.get(this));
  }

  public static void main(String[] args) throws IllegalAccessException, NoSuchFieldException {
    MostlyFinal test = new MostlyFinal();

    System.out.println("direct: primitiveInt = " + test.getPrimitiveInt());
    test.changeField("primitiveInt", 84);
    System.out.println("direct: primitiveInt = " + test.getPrimitiveInt());

    System.out.println();

    System.out.println("direct: wrappedInt = " + test.getWrappedInt());
    test.changeField("wrappedInt", 84);
    System.out.println("direct: wrappedInt = " + test.getWrappedInt());

    System.out.println();

    System.out.println("direct: stringValue = " + test.getStringValue());
    test.changeField("stringValue", "84");
    System.out.println("direct: stringValue = " + test.getStringValue());
  }
}

这是我得到的输出（在Eclipse，Java 1.6下）

direct: primitiveInt = 42
reflection: primitiveInt = 84
direct: primitiveInt = 42

direct: wrappedInt = 42
reflection: wrappedInt = 84
direct: wrappedInt = 84

direct: stringValue = 42
reflection: stringValue = 84
direct: stringValue = 42

为什么heck直接调用getWrappedInt（）会改变？

Answer 5

有一个解决方法。如果你在static {}块中设置private static final字段的值，它将起作用，因为它不会内联fileld：

private static final String MY_FIELD;

static {
    MY_FIELD = "SomeText"
}

...

Field field = VisitorId.class.getDeclaredField("MY_FIELD");

field.setAccessible(true);
field.set(field, "fakeText");

修改Java中的最终字段

5 个答案: