Why is it not possible to modify local variables when accessed within anonymous classes?

Question

When trying to access a local variable from a method of an anonymous class in java, we usually get a syntax error if we try to modify its content. Some Fdis suggest that we turn the variable into final, thus, its content becomes immutable, but then the error changes, and becomes the attempt to access a content that cannot be changed.

However, if we only read its content, even not modifying to final, no error is presented and the code works normally, with the copy of the content being made without problems.

But when you create a class variable and try to access within the anonymous class, not only can you read its content, but it is also allowed to be changed, as can be seen in the example below:

public class AccessLevelVariableTest {

    private String oneVariable = "oneVariable";


    public void myMethod() {

        String localVariable = "localVariable";

        JButton btn = new JButton();

        btn.addActionListener(new ActionListener(){

            @Override
            public void actionPerformed(ActionEvent evt){

                oneVariable = localVariable; //isso é permitido
                System.out.println(localVariable); //isso é permitido
                localVariable = oneVariable; // isso ocorre erro de sinxate

            }
        });
    }
}

If the local variable is viewed by the anonymous class, I believe it is not a problem linked only to its scope, so what is the point of restricting access to a local variable in this way, different from the class variable? What kind of impact could such a change cause to have such a restriction?

Answer 1

Responding briefly - and I’m no expert on Java -, this is due to the way Java handles closures. What Java makes available to the anonymous class is not the variables themselves (i.e., references to certain values), but their values. Thus, if the variable is changed in the external scope, this will not be reflected in the anonymous class. In the same way, as if it has only one value unlinked from the original variable, it is not possible to change it - if the language allowed, this change would only have effect within the anonymous class, and this would be confusing.

Such functioning probably was a deliberate choice, to avoid the additional complexity that this would require of the compiler. C# works differently (with very similar syntax), because it made a different choice.

Source: Why are only final variables accessible in Anonymous class?, answer from Jon Skeet

Answer 2

localVariable only exists during the execution of the method myMethod(). Since the created object can exist in the external scope of the method, the variable localVariable there will be no more.