Great question—this is one of those Java nuances that feels arbitrary at first, but makes total sense once you dig into how inner and anonymous classes work under the hood. Let’s break this down clearly:

First, a quick clarification to avoid confusion: You don’t need to mark outer class member fields as final for inner/anonymous classes to access them. That requirement only applies to local variables (variables declared inside a method) or method parameters that the inner/anonymous class wants to use.

Now, why that requirement for local variables/parameters? Let’s start with how Java handles these variables when an inner class captures them:

• Local variables live on the stack: When a method finishes executing, all its local variables are popped off the stack and destroyed. But an inner class (like an anonymous Runnable you pass to a Thread) might outlive the method—think of a background thread that runs long after the original method has completed.
• Java copies the variable’s value to the inner class: To let the inner class access the variable even after the method is gone, Java creates a copy of the variable’s value and stores it inside the inner class’s instance.
• Consistency is key: If the original local variable could be modified after the inner class is created, the copy inside the inner class would no longer match the original. This would lead to weird, hard-to-debug behavior where the inner class uses a stale value. By requiring the variable to be final (or effectively final in Java 8+), Java ensures the value never changes—so the copy and the original are always the same.

What’s "effectively final"? That’s a Java 8+ feature where you don’t have to write the final keyword explicitly, as long as you never modify the variable after initializing it. Java treats it as if it were final automatically. For example:

public void startTask() {
    String taskName = "Backup"; // Effectively final—no changes after this line
    new Thread(new Runnable() {
        @Override
        public void run() {
            System.out.println("Running task: " + taskName); // Works fine in Java 8+
        }
    }).start();
}

If you tried to add taskName = "Sync"; after initializing it, Java would throw an error because the variable is no longer effectively final.

To recap:

• Outer class member fields: No final needed—inner classes hold a reference to the outer class instance, so they can access and modify these fields directly (since they live on the heap, not the stack).
• Local variables/method parameters: Must be final or effectively final to ensure the value copied to the inner class instance stays consistent with the original.

This rule isn’t just a random restriction—it’s Java’s way of preventing subtle bugs caused by mismatched variable values between the outer scope and the inner class.

内容的提问来源于stack exchange，提问作者Positive