Java stopped erroring on non-final variables in inner classes (java 8) [duplicate]

Question

Java 7 was saying "Cannot refer to the non-final local variable message defined in an enclosing scope" on following code:

public class Runner {   
    public static void main(String[] args) {

        String message = "Hello world";

        new Runnable() {
            @Override
            public void run() {
                System.out.println(message);
            }
        }.run();
    }
}

Java 8 does not.

Suspect this is about adding functional programming features to Java.

Does it process the code similarly?

Answer 1

Java 8 implicitly makes message final because it is never modified. Try modifying it anywhere in your code and you will get a compilation error (because this removes the implicit final).

This is called effectively final. Quoting From the docs:

However, starting in Java SE 8, a local class can access local variables and parameters of the enclosing block that are final or effectively final. A variable or parameter whose value is never changed after it is initialized is effectively final.

Answer 2

Java 8 (and Lambdas) introduce the effectively final term: even though you didn't delcare it final with the final keyword, if it is not modified, it is as good as final.

Quoting from Oracle Tutorial: Local Classes:

However, starting in Java SE 8, a local class can access local variables and parameters of the enclosing block that are final or effectively final. A variable or parameter whose value is never changed after it is initialized is effectively final.

Your message is effectively final so it is valid to refer to it from anonymous inner classes and lambdas.

If you change the value of the message, it will not be effectively final anymore:

String message = "Hello world";
new Runnable() {
    @Override
    public void run() {
        System.out.println(message);
    }
}.run();
message = "modified";

And therefore you get the following error (from Eclipse):

Local variable message defined in an enclosing scope must be final or effectively final

Or form javac:

error: local variables referenced from an inner class must be final or effectively final

Answer 3

The variable message is effectively final. Quoting from language reference

If a variable is effectively final, adding the final modifier to its declaration will not introduce any compile-time errors.

Hence, because message reference is not changed anywhere within you inner class, the compiler treats it as effectively final.

This would have thrown error:

new Runnable() {
            @Override
            public void run() {
                message = "hey";
                System.out.println(message);
            }
        }.run();

The reason, java7 compiler throws error is because of a spec change for lambdas.

Any local variable, formal parameter, or exception parameter used but not Any local variable, formal parameter, or exception parameter used but not declared in a lambda expression must either be declared final or be effectively final (§4.12.4), or a compile-time error occurs where the use is attempted.

Anonymous Inner classes and lambdas share the same rules.