You CAN Change Final Fields

Tim Vernum pointed out a mistake in my last post. I said this:

Yikes. As expected, you CANNOT change final fields. Phew! But surprisingly, attempting to set the value does not throw an exception. Instead, it silently ignores your request.

Which is completely wrong. You can change final fields. And the results are surprising to say the least, so even though you can do this, you probably should not.

Let’s Change It

Recall the Caveman class, with its final age field:

public class Caveman {
    private String name;
    private final int age = 10;

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }
}

Since the age is final and private, we must use reflection if we wish to change it:

Field ageField = Caveman.class.getDeclaredField("age");

// this lets us change private fields
ageField.setAccessible(true);

ageField.setInt(caveman, 100);

System.out.println("Age is now " + caveman.getAge());

This is where I got confused, because the program prints:

Age is now 10

My Mistake

If you run the program in a debugger and inspect the age, you will find it is actually changed to 100. The program prints 10, however, since the compiler optimized the code. Despite the fact that I used reflection to change the value, the optimized method is still…well…optimized.

As you can see, this can lead to very confusing results. For instance, you can use reflection to obtain the correct value:

System.out.println("REAL age is: " + ageField.getInt(caveman));

This gets the new 100 value, instead of the original 10.

Now Wrap Your Noodle Around This

Now change the Caveman class to initialize the age in its constructor, instead:

public class Caveman {
    private String name;
    private final int age;

    public Caveman() {
        age = 10;
    }

   ...

Now when you call the getAge() method, even after changing the field via reflection, you get the correct answer of 100.

In Summary

Here is what I learned:

• You CAN change final fields via reflection. (yikes)
• The compiler sometimes optimizes things, thus your programs may not see the modified data.
• Initialization of final fields in constructors versus inline assignment can affect the optimizations.
• You probably SHOULD NOT attempt to change final fields via reflection, because Weird Things happen.

This entry was posted on Saturday, October 13th, 2007 at 8:13 pm and is filed under Java. You can skip to the end and leave a response.