如果你的字段是私有的，你可以这样做:

MyClass myClass= new MyClass();
Field aField= myClass.getClass().getDeclaredField("someField");
aField.setAccessible(true);
aField.set(myClass, "newValueForAString");

和抛出/处理NoSuchFieldException

如果你的字段是私有的，你可以这样做:

MyClass myClass= new MyClass();
Field aField= myClass.getClass().getDeclaredField("someField");
aField.setAccessible(true);
aField.set(myClass, "newValueForAString");

和抛出/处理NoSuchFieldException

即使是final字段，也可以在静态初始化器之外修改，并且(至少JVM HotSpot)将完美地执行字节码。

问题是Java编译器不允许这样做，但是可以使用objectweb.asm轻松绕过。从JVM规范的角度来看，这是一个无效的类文件，但它通过了字节码验证，然后在JVM HotSpot OpenJDK12下成功加载和初始化:

ClassWriter cw = new ClassWriter(0);
cw.visit(Opcodes.V1_8, Opcodes.ACC_PUBLIC, "Cl", null, "java/lang/Object", null);
{
    FieldVisitor fv = cw.visitField(Opcodes.ACC_PRIVATE | Opcodes.ACC_STATIC | Opcodes.ACC_FINAL, "fld", "I", null, null);
    fv.visitEnd();
}
{
    // public void setFinalField1() { //... }
    MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "setFinalField1", "()V", null, null);
    mv.visitMaxs(2, 1);
    mv.visitInsn(Opcodes.ICONST_5);
    mv.visitFieldInsn(Opcodes.PUTSTATIC, "Cl", "fld", "I");
    mv.visitInsn(Opcodes.RETURN);
    mv.visitEnd();
}
{
    // public void setFinalField2() { //... }
    MethodVisitor mv = cw.visitMethod(Opcodes.ACC_PUBLIC | Opcodes.ACC_STATIC, "setFinalField2", "()V", null, null);
    mv.visitMaxs(2, 1);
    mv.visitInsn(Opcodes.ICONST_2);
    mv.visitFieldInsn(Opcodes.PUTSTATIC, "Cl", "fld", "I");
    mv.visitInsn(Opcodes.RETURN);
    mv.visitEnd();
}
cw.visitEnd();

在Java中，该类大致如下所示:

public class Cl{
    private static final int fld;

    public static void setFinalField1(){
        fld = 5;
    }

    public static void setFinalField2(){
        fld = 2;
    }
}

它不能用javac编译，但可以由JVM加载和执行。

JVM HotSpot对这样的类有特殊处理，因为它阻止这样的“常量”参与常量折叠。这个检查是在类初始化的字节码重写阶段完成的:

// Check if any final field of the class given as parameter is modified
// outside of initializer methods of the class. Fields that are modified
// are marked with a flag. For marked fields, the compilers do not perform
// constant folding (as the field can be changed after initialization).
//
// The check is performed after verification and only if verification has
// succeeded. Therefore, the class is guaranteed to be well-formed.
InstanceKlass* klass = method->method_holder();
u2 bc_index = Bytes::get_Java_u2(bcp + prefix_length + 1);
constantPoolHandle cp(method->constants());
Symbol* ref_class_name = cp->klass_name_at(cp->klass_ref_index_at(bc_index));
if (klass->name() == ref_class_name) {
   Symbol* field_name = cp->name_ref_at(bc_index);
   Symbol* field_sig = cp->signature_ref_at(bc_index);

   fieldDescriptor fd;
   if (klass->find_field(field_name, field_sig, &fd) != NULL) {
      if (fd.access_flags().is_final()) {
         if (fd.access_flags().is_static()) {
            if (!method->is_static_initializer()) {
               fd.set_has_initialized_final_update(true);
            }
          } else {
            if (!method->is_object_initializer()) {
              fd.set_has_initialized_final_update(true);
            }
          }
        }
      }
    }
}

JVM HotSpot检查的唯一限制是final字段不应该在final字段声明所在的类之外修改。

Java语言规范，第17章，第17.5.4节“写保护字段”:

通常，final和static字段不能被修改。 然而,系统。在系统。out和System。Err是静态的最终字段 由于遗留的原因，必须允许方法对其进行更改 系统。开始,系统。setOut和System.setErr。我们提到这些 字段被写入保护，以区别于普通字段 最后一个字段。

来源:http://docs.oracle.com/javase/specs/jls/se7/html/jls - 17. # jls-17.5.4 html

如果赋给一个静态final布尔字段的值在编译时是已知的，那么它就是一个常量。原始或原始字段 字符串类型可以是编译时常量。常量将内联到引用该字段的任何代码中。由于字段在运行时并不实际读取，因此更改它将没有任何影响。

Java语言规范是这样说的:

如果一个场是常数变量 (§4.12.4)，然后删除关键字 Final或改变其值将不会 打破与既存状况的兼容性 通过让二进制文件不运行， 但他们不会看到任何新的价值 对于字段的使用，除非他们 重新编译。这是真的，即使 用法本身不是编译时 常量表达式(§15.28)

这里有一个例子:

class Flag {
  static final boolean FLAG = true;
}

class Checker {
  public static void main(String... argv) {
    System.out.println(Flag.FLAG);
  }
}

如果你反编译Checker，你会看到它而不是引用Flag。FLAG，代码只是将一个值1 (true)压入堆栈(指令#3)。

0:   getstatic       #2; //Field java/lang/System.out:Ljava/io/PrintStream;
3:   iconst_1
4:   invokevirtual   #3; //Method java/io/PrintStream.println:(Z)V
7:   return

这里的许多答案都很有用，但我发现没有一个在Android上特别适用。我甚至是joor的Reflect的忠实用户，无论是它还是apache的FieldUtils——在这里的一些答案中都提到了这一点。

Android的问题

这样做的根本原因是，在Android上，field类中没有修饰符字段，这使得任何涉及这段代码的建议(如在标记的答案中)都是无用的:

Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

事实上，引用FieldUtils.removeFinalModifier():

// Do all JREs implement Field with a private ivar called "modifiers"?
final Field modifiersField = Field.class.getDeclaredField("modifiers");

所以，答案是否定的……

解决方案

非常简单——字段名是accessFlags，而不是修饰符。这招很管用:

Field accessFlagsField = Field.class.getDeclaredField("accessFlags");
accessFlagsField.setAccessible(true);
accessFlagsField.setInt(field, field.getModifiers() & ~Modifier.FINAL);

旁注#1:无论字段在类中是否是静态的，这都可以工作。

旁注#2:鉴于字段本身可能是私有的，建议也启用对字段本身的访问，使用field. setaccessible (true)(除了accessFlagsField.setAccessible(true))。