要理解这种限制的基本原理，请考虑以下程序:

public class Program {

    interface Interface {
        public void printInteger();
    }
    static Interface interfaceInstance = null;

    static void initialize(int val) {
        class Impl implements Interface {
            @Override
            public void printInteger() {
                System.out.println(val);
            }
        }
        interfaceInstance = new Impl();
    }

    public static void main(String[] args) {
        initialize(12345);
        interfaceInstance.printInteger();
    }
}

The interfaceInstance remains in memory after the initialize method returns, but the parameter val does not. The JVM can’t access a local variable outside its scope, so Java makes the subsequent call to printInteger work by copying the value of val to an implicit field of the same name within interfaceInstance. The interfaceInstance is said to have captured the value of the local parameter. If the parameter weren’t final (or effectively final) its value could change, becoming out of sync with the captured value, potentially causing unintuitive behavior.

有一个技巧允许匿名类在外部作用域中更新数据。

private void f(Button b, final int a) {
    final int[] res = new int[1];
    b.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            res[0] = a * 5;
        }
    });

    // But at this point handler is most likely not executed yet!
    // How should we now res[0] is ready?
}

然而，由于同步问题，这个技巧不是很好。如果处理程序稍后被调用，你需要1)同步访问res，如果处理程序从不同的线程调用2)需要有某种标志或指示res被更新

但是，如果匿名类在同一个线程中立即被调用，这个技巧就可以工作。如:

// ...

final int[] res = new int[1];
Runnable r = new Runnable() { public void run() { res[0] = 123; } };
r.run();
System.out.println(res[0]);

// ...

也许这个把戏能给你启发

Boolean var= new anonymousClass(){
    private String myVar; //String for example
    @Overriden public Boolean method(int i){
          //use myVar and i
    }
    public String setVar(String var){myVar=var; return this;} //Returns self instane
}.setVar("Hello").method(3);

访问被限制为局部final变量的原因是，如果所有的局部变量都是可访问的，那么它们首先需要被复制到一个单独的部分，在那里内部类可以访问它们，并且维护可变局部变量的多个副本可能会导致数据不一致。而final变量是不可变的，因此任何数量的拷贝都不会对数据的一致性产生任何影响。

Java匿名类与Javascript闭包非常相似，但Java以不同的方式实现。(请看安徒生的答案)

所以为了不让Java开发人员对那些有Javascript背景的人的奇怪行为感到困惑。我想这就是为什么他们强迫我们使用final，这不是JVM的限制。

让我们看看下面的Javascript例子:

var add = (function () {
  var counter = 0;

  var func = function () {
    console.log("counter now = " + counter);
    counter += 1; 
  };

  counter = 100; // line 1, this one need to be final in Java

  return func;

})();


add(); // this will print out 100 in Javascript but 0 in Java

在Javascript中，计数器的值是100，因为从头到尾只有一个计数器变量。

但在Java中，如果没有final，它将打印出0，因为在创建内部对象时，0值被复制到内部类对象的隐藏属性中。(这里有两个整数变量，一个在局部方法中，另一个在内部类隐藏属性中)

因此，内部对象创建后的任何更改(如第1行)都不会影响内部对象。所以它会混淆两种不同的结果和行为(Java和Javascript之间)。

我相信这就是为什么，Java决定强制它是最终的，所以数据从开始到结束都是“一致的”。

您可以创建一个类级别的变量来获取返回值。我的意思是

class A {
    int k = 0;
    private void f(Button b, int a){
        b.addClickHandler(new ClickHandler() {
        @Override
        public void onClick(ClickEvent event) {
            k = a * 5;
        }
    });
}

现在你可以得到K的值，并在你想要的地方使用它。

你的答案是:

局部内部类实例绑定到Main类，可以访问其包含方法的最终局部变量。当实例使用其包含方法的final局部时，即使变量超出了作用域(这实际上是Java中粗糙的、有限版本的闭包)，变量也会保留它在创建实例时所持有的值。

因为局部内部类既不是类的成员也不是包的成员，所以没有使用访问级别声明它。(但是要清楚的是，它自己的成员像普通类一样具有访问级别。)