由于Jon有实现细节的答案，另一个可能的答案是JVM不想处理已经结束他的激活的写入记录。

考虑这样一个用例，在这个用例中，你的lambdas不是被应用的，而是被存储在某个地方并稍后运行。

我记得在Smalltalk中，当你做这样的修改时，你会得到一个非法的商店。

匿名内部类中的方法可以在生成该类的线程终止后调用。在您的示例中，内部类将在事件分派线程上调用，而不是在创建它的线程中调用。因此，变量的作用域是不同的。所以为了保护这样的变量赋值范围问题，你必须声明它们为final。

正如注释中提到的，其中一些在Java 8中变得无关紧要，在Java 8中final可以是隐式的。但是，只有有效的final变量才能用于匿名内部类或lambda表达式。

这主要是由于Java管理闭包的方式。

When you create an instance of an anonymous inner class, any variables which are used within that class have their values copied in via the autogenerated constructor. This avoids the compiler having to autogenerate various extra types to hold the logical state of the "local variables", as for example the C# compiler does... (When C# captures a variable in an anonymous function, it really captures the variable - the closure can update the variable in a way which is seen by the main body of the method, and vice versa.)

As the value has been copied into the instance of the anonymous inner class, it would look odd if the variable could be modified by the rest of the method - you could have code which appeared to be working with an out-of-date variable (because that's effectively what would be happening... you'd be working with a copy taken at a different time). Likewise if you could make changes within the anonymous inner class, developers might expect those changes to be visible within the body of the enclosing method.

Making the variable final removes all these possibilities - as the value can't be changed at all, you don't need to worry about whether such changes will be visible. The only ways to allow the method and the anonymous inner class see each other's changes is to use a mutable type of some description. This could be the enclosing class itself, an array, a mutable wrapper type... anything like that. Basically it's a bit like communicating between one method and another: changes made to the parameters of one method aren't seen by its caller, but changes made to the objects referred to by the parameters are seen.

如果您对Java和c#闭包之间更详细的比较感兴趣，我有一篇文章对此进行了进一步的讨论。在这个答案中，我想专注于Java方面:)

也许这个把戏能给你启发

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);

When an anonymous inner class is defined within the body of a method, all variables declared final in the scope of that method are accessible from within the inner class. For scalar values, once it has been assigned, the value of the final variable cannot change. For object values, the reference cannot change. This allows the Java compiler to "capture" the value of the variable at run-time and store a copy as a field in the inner class. Once the outer method has terminated and its stack frame has been removed, the original variable is gone but the inner class's private copy persists in the class's own memory.

(http://en.wikipedia.org/wiki/Final_%28Java%29)

在Java中，变量不仅可以作为参数，还可以作为类级字段，例如

public class Test
{
 public final int a = 3;

或者作为一个局部变量

public static void main(String[] args)
{
 final int a = 3;

如果希望访问和修改匿名类中的变量，则可能希望将该变量设置为外围类中的类级变量。

public class Test
{
 public int a;
 public void doSomething()
 {
  Runnable runnable =
   new Runnable()
   {
    public void run()
    {
     System.out.println(a);
     a = a+1;
    }
   };
 }
}

你不能把一个变量作为final，然后给它一个新值。Final的意思就是:值是不可改变的和Final的。

由于它是最终的，Java可以安全地将其复制到本地匿名类。你没有得到对int的引用(特别是因为你在Java中不能有对int这样的原语的引用，只能引用对象)。

它只是将a的值复制到一个隐式int，在匿名类中称为a。