使用匿名类，实际上是在声明一个“无名称”嵌套类。对于嵌套类，编译器生成一个新的独立的公共类，其中带有一个构造函数，该构造函数将使用所有变量作为参数(对于“命名”嵌套类，这始终是原始/外围类的实例)。这样做是因为运行时环境没有嵌套类的概念，因此需要从嵌套类(自动)转换到独立类。
以下面的代码为例:
public class EnclosingClass {
public void someMethod() {
String shared = "hello";
new Thread() {
public void run() {
// this is not valid, won't compile
System.out.println(shared); // this instance expects shared to point to the reference where the String object "hello" lives in heap
}
}.start();
// change the reference 'shared' points to, with a new value
shared = "other hello";
System.out.println(shared);
}
}
这是行不通的，因为这是编译器在底层所做的:
public void someMethod() {
String shared = "hello";
new EnclosingClass$1(shared).start();
// change the reference 'shared' points to, with a new value
shared = "other hello";
System.out.println(shared);
}
原来的匿名类被编译器生成的一些独立的类所取代(代码不精确，但应该给你一个很好的想法):
public class EnclosingClass$1 extends Thread {
String shared;
public EnclosingClass$1(String shared) {
this.shared = shared;
}
public void run() {
System.out.println(shared);
}
}
As you can see, the standalone class holds a reference to the shared object, remember that everything in java is pass-by-value, so even if the reference variable 'shared' in EnclosingClass gets changed, the instance it points to is not modified, and all other reference variables pointing to it (like the one in the anonymous class: Enclosing$1), will not be aware of this. This is the main reason the compiler forces you to declare this 'shared' variables as final, so that this type of behavior won't make it into your already running code.
现在，这是当你在匿名类中使用实例变量时发生的事情(这是你应该做的来解决你的问题，将你的逻辑移动到一个“实例”方法或类的构造函数):
public class EnclosingClass {
String shared = "hello";
public void someMethod() {
new Thread() {
public void run() {
System.out.println(shared); // this is perfectly valid
}
}.start();
// change the reference 'shared' points to, with a new value
shared = "other hello";
System.out.println(shared);
}
}
这可以很好地编译，因为编译器会修改代码，这样新生成的类EnclosingClass $1将持有它被实例化的EnclosingClass实例的引用(这只是一个表示，但应该会让你继续下去):
public void someMethod() {
new EnclosingClass$1(this).start();
// change the reference 'shared' points to, with a new value
shared = "other hello";
System.out.println(shared);
}
public class EnclosingClass$1 extends Thread {
EnclosingClass enclosing;
public EnclosingClass$1(EnclosingClass enclosing) {
this.enclosing = enclosing;
}
public void run() {
System.out.println(enclosing.shared);
}
}
就像这样，当EnclosingClass中的引用变量“shared”被重新赋值时，这发生在调用Thread#run()之前，你会看到“other hello”打印了两次，因为现在EnclosingClass$1#封闭变量将保持对它声明的类对象的引用，因此对该对象上的任何属性的更改将对EnclosingClass$1的实例可见。
关于这个主题的更多信息，你可以看到这篇优秀的博客文章(不是我写的):http://kevinboone.net/java_inner.html
