Java reflection does not work as expected

Question

I just wrote this code to test something for a better understanding of reflection.

This is the ReflectionTestMain class:

import java.lang.reflect.Field;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;

public class ReflectionTestMain {
    public static void main(String[] args) {
        try {
            ReflectionTest rt = new ReflectionTest();
            Class<ReflectionTest> c = ReflectionTest.class;
            Field f = c.getDeclaredField("value");
            f.setAccessible(true);
            f.set(rt, "text");
            Method m = c.getDeclaredMethod("getValue");
            m.setAccessible(true);
            String value = (String) m.invoke(rt);
            System.out.println(value);
        } catch (NoSuchFieldException | SecurityException | IllegalArgumentException | IllegalAccessException | NoSuchMethodException | InvocationTargetException e) {
            e.printStackTrace();
        }
    }
}

And this is the ReflectionTest class.

public class ReflectionTest {
    private final String value = "test";

    private String getValue() {
        return value;
    }
}

This code prints test but I expected it prints text. What is the reason that this does not work and how can I fix that?

I don't know much about reflection however, could it be the reason that your `value` is declared as `final` — Sandeep Singh, Mar 15 '18 at 09:55

Ferrybig · Accepted Answer · 2018-03-15T10:07:36.460

While the variable is properly updated, it isn't propagated to the getValue() method.

The reason for this is that the compiler optimizes the program for you.

Since the compiler knows that the variable value is not changed, it compiles it to inline access directly to the string pool, instead of going through the variable. This can be sees by running java -p on the class file

This can be solved by using a initizer block or constructor for the string constant, or making the statement more complex to "fool" the compiler.

class ReflectionTest {


    // Use either
    private final String value;
    {
        value = "test";
    }
    // Or 
    private final String value;
    public ReflectionTest () {
        value = "test";
    }
    // Or
    private final String value = Function.identity().apply("test");
    // Or

    //   Do not replace with + as the compiler is too smart
    private final String value = "test".concat(""); 
    // Depending on your required performance/codestyling analyses

    private String getValue() {
        return value;
    }

}

Instead of `"test".concat("")` you can simply use `"test".toString()`. This isn’t even about smartness, as the Java Language Specification precisely mandates this behavior, which is more than an optimization, e.g. specifying that `"test"+""` still is a compile-time constant implies that you can use it as `case` label in a `switch` statement or in an annotation. — Holger, Mar 15 '18 at 11:51

score 1 · Answer 2 · answered Mar 15 '18 at 10:03

From javadoc on Field.set(..)

 * <p>If the underlying field is final, the method throws an
 * {@code IllegalAccessException} unless {@code setAccessible(true)}
 * has succeeded for this {@code Field} object
 * and the field is non-static. Setting a final field in this way
 * is meaningful only during deserialization or reconstruction of
 * instances of classes with blank final fields, before they are
 * made available for access by other parts of a program. Use in
 * any other context may have unpredictable effects, including cases
 * in which other parts of a program continue to use the original
 * value of this field.

So you just use reflection in an incorrect way here.

Java reflection does not work as expected

2 Answers2