changing final variables through reflection, why difference between static and non-static final variable

Question

Please refer to the below code. When I run the code, I am able to change the value of a final non-static variable. But if I try to change the value of a final static variable then it throws java.lang.IllegalAccessException.

My question is why doesn't it throw an exception in case of non-static final variable also or vice versa. Why the difference?

import java.lang.reflect.Field;
import java.util.Random;

public class FinalReflection {

    final static int stmark =  computeRandom();
    final int inmark = computeRandom();

    public static void main(String[] args) throws SecurityException, NoSuchFieldException, IllegalArgumentException, IllegalAccessException {
        FinalReflection obj = new FinalReflection();
        System.out.println(FinalReflection.stmark);
        System.out.println(obj.inmark);
        Field staticFinalField  = FinalReflection.class.getDeclaredField("stmark");
        Field instanceFinalField  = FinalReflection.class.getDeclaredField("inmark");
        staticFinalField.setAccessible(true);
        instanceFinalField.setAccessible(true);

        instanceFinalField.set(obj, 100);
        System.out.println(obj.inmark);

        staticFinalField.set(FinalReflection.class, 101);
        System.out.println(FinalReflection.stmark);

    }

    private static int computeRandom() {
        return new Random().nextInt(5);
    }
}

I have posted the code which does not give exception. But it is a hack for sure. — Narendra Pathai, Aug 08 '13 at 11:23

score 10 · Accepted Answer · edited May 23 '17 at 12:24

FinalReflectionobj = new FinalReflection();
System.out.println(FinalReflection.stmark);
System.out.println(obj.inmark);
Field staticFinalField  = FinalReflection.class.getDeclaredField("stmark");
Field instanceFinalField  = FinalReflection.class.getDeclaredField("inmark");
staticFinalField.setAccessible(true);
instanceFinalField.setAccessible(true);

//EXTRA CODE
//Modify the final using reflection
Field modifiersField = Field.class.getDeclaredField("modifiers");
modifiersField.setAccessible(true);
modifiersField.setInt(staticFinalField, staticFinalField.getModifiers() & ~Modifier.FINAL);


instanceFinalField.set(obj, 100);
System.out.println(obj.inmark);
staticFinalField.set(FinalReflection.class, 101);
System.out.println(FinalReflection.stmark);

This solution does not come without some downsides, it may not work in all cases:

In case a final field is initialized to a compile-time constant in the field declaration, changes to the final field may not be visible, since uses of that final field are replaced at compile time with the compile-time constant.

Another problem is that the specification allows aggressive optimization of final fields. Within a thread, it is permissible to reorder reads of a final field with those modifications of a final field that do not take place in the constructor. More on this is also explained in this similar question.

@assylias this will allow you to change the static final field too if there is no security manager. — Narendra Pathai, Aug 08 '13 at 11:22
Note that this won't work with static final primitives initialised with a constant expression. — assylias, Aug 08 '13 at 11:41
@assylias yeah this does not work always, but will work in this case. Thanks for pointing it out. I will add the cases too. — Narendra Pathai, Aug 08 '13 at 11:43

score 2 · Answer 2 · edited May 23 '17 at 12:01

2

The javadoc is clear:

If the underlying field is final, the method throws an IllegalAccessException unless setAccessible(true) has succeeded for this Field object and the field is non-static.

From a JLS perspective, the exact behaviour of how reflection should work is not specified, but in JLS 17.5.4:

Normally, a field that is final and static may not be modified.

One workaround is to remove the final modifier through reflection.

edited May 23 '17 at 12:01

Community

1
1

answered Aug 08 '13 at 11:18

assylias

321,522
82
660
783

1

Excelent answer, but I think the question rather is: why did the java designers decide this? – morgano Aug 08 '13 at 11:26
@morgano if that is the case SO is probably not the best place to ask! It certainly causes all sorts of issues. For example primitive constants are inlined at compile time, so you can't change them at runtime unless you change the underlying bytecode. – assylias Aug 08 '13 at 11:30
@assylias thanks for the excellent info. but yes my question was little aligned towards what morgano said. But yes I couldn't agree more that SO may not be the best place to ask this.I'll mind it from next time. Anyways primitive being inlined goes for both static and non-static final variables. try running the modified code value 5 instead of computeRandom(). – veritas Aug 08 '13 at 12:22

score 0 · Answer 3 · answered Aug 08 '13 at 11:15

For final, it can be assigned different values at runtime when initialized.

Class Test{    
public final int a;
}

Test t1  = new Test();
t1.a = 10;
Test t2  = new Test();
t1.a = 20;

Thus each instance has different value of field a.

For static final, all instances share the same value, and can't be altered after first initialized.

Class TestStatic{
   public static final int a;
}

Test t1  = new Test();
t1.a = 10;
Test t2  = new Test();
t1.a = 20;   // ERROR, CAN'T BE ALTERED AFTER THE FIRST INITIALIZATION.

But he uses only one single instance of the class. And a non-static final variable is not changeable after the first assignment. Therefore this explanation is wrong. — Uwe Plonus, Aug 08 '13 at 11:17

changing final variables through reflection, why difference between static and non-static final variable

3 Answers3

Linked