java - 为什么匿名类不能访问其封闭类的变量？

Question

This question already has answers here:

Why are only final variables accessible in anonymous class?

(15个答案)


7年前关闭。




我正在阅读有关Java中匿名类的信息，它说您可以访问封闭类的方法，但不能访问局部变量。为什么会这样呢？我在说这个:

编辑:较旧的示例是不正确的不反射(reflect)我的意思。根据在“访问封闭类的成员”一节 http://docs.oracle.com/javase/tutorial/java/javaOO/localclasses.html中的内容，这应该是一个更好的示例。

public class MyClass {
    public interface SomeInterface{
        public void someOtherMethod();
    }

    public void someMethod(int someLocalVar) {
        SomeInterface myClass = new SomeInterface(){
            public void someOtherMethod(){
                someLocalVar = 0; // This must be final to work
            }
        }
    }
}

那么这个限制解决了什么问题呢？

最佳答案

这来自早期版本的Java内部类规范。

链接腐烂的官方规范URL(例如，从VM spec 2.14引用)已消失:http://java.sun.com/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc.html

虽然可以在Wayback机上获得1999年1月17日的快照，但相应的规格节为References to local variables。

事情的工作方式描述如下(我将最相关的语句标记为粗体):

A class definition which is local to a block may access local variables. This complicates the compiler's job. Here is the previous example of a local class:

    Enumeration myEnumerate(final Object array[]) {
        class E implements Enumeration {
            int count = 0;
            public boolean hasMoreElements()
                { return count < array.length; }
            public Object nextElement() {
                { return array[count++]; }
        }
        return new E();
    }

In order to make a local variable visible to a method of the inner class, the compiler must copy the variable's value into a place where the inner class can access it. References to the same variable may use different code sequences in different places, as long as the same value is produced everywhere, so that the name consistently appears to refer to the same variable in all parts of its scope.

By convention, a local variable like array is copied into a private field val$array of the inner class. (Because array is final, such copies never contain inconsistent values.) ...

您会看到，语言设计者希望每次创建这样的副本时复制的局部变量的值都“一致”。他们的动机很可能是开发人员不必担心在内部类的副本之外查看它是否已更改:

Enumeration myEnumerate(Object array[], int copy) { // array not final, let's see...
    for (int i = 0, i < 2; i++ ) { // loop to have several copies
        class E implements Enumeration {
            int count = 0;
            public boolean hasMoreElements()
                { return count < array.length; }
            public Object nextElement() {
                { return array[count++]; }
        } // we hope to be done with E... oh no 

        array = null; // not final => can change

        if (i == copy) {
            return new E(); // we need to look outside of E
            // to figure value of array it uses
        }
    }
    return null;
}

请注意，尽管规范示例使用命名类，但相同的推理也适用于匿名类:

// ...
    for (int i = 0, i < 2; i++ ) { // loop to have several copies
        if (i == copy) {
            return new Enumeration() {
                int count = 0;
                public boolean hasMoreElements()
                    { return count < array.length; }
                public Object nextElement() {
                    { return array[count++]; }
            } // we hope to be done... oh no
        }

        array = null; // not final => can change
    }

关于java - 为什么匿名类不能访问其封闭类的变量？ ，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/17736620/

上一篇：java - 任何获取 HTTP GET、POST、PUT、DELETE 常量的方法？

下一篇：java - 确定 ByteBuffer 中的字节数

Answer 1

这来自早期版本的Java内部类规范。

链接腐烂的官方规范URL(例如，从VM spec 2.14引用)已消失:http://java.sun.com/products/jdk/1.1/docs/guide/innerclasses/spec/innerclasses.doc.html

虽然可以在Wayback机上获得1999年1月17日的快照，但相应的规格节为References to local variables。

事情的工作方式描述如下(我将最相关的语句标记为粗体):

A class definition which is local to a block may access local variables. This complicates the compiler's job. Here is the previous example of a local class:

    Enumeration myEnumerate(final Object array[]) {
        class E implements Enumeration {
            int count = 0;
            public boolean hasMoreElements()
                { return count < array.length; }
            public Object nextElement() {
                { return array[count++]; }
        }
        return new E();
    }

In order to make a local variable visible to a method of the inner class, the compiler must copy the variable's value into a place where the inner class can access it. References to the same variable may use different code sequences in different places, as long as the same value is produced everywhere, so that the name consistently appears to refer to the same variable in all parts of its scope.

By convention, a local variable like array is copied into a private field val$array of the inner class. (Because array is final, such copies never contain inconsistent values.) ...

您会看到，语言设计者希望每次创建这样的副本时复制的局部变量的值都“一致”。他们的动机很可能是开发人员不必担心在内部类的副本之外查看它是否已更改:

Enumeration myEnumerate(Object array[], int copy) { // array not final, let's see...
    for (int i = 0, i < 2; i++ ) { // loop to have several copies
        class E implements Enumeration {
            int count = 0;
            public boolean hasMoreElements()
                { return count < array.length; }
            public Object nextElement() {
                { return array[count++]; }
        } // we hope to be done with E... oh no 

        array = null; // not final => can change

        if (i == copy) {
            return new E(); // we need to look outside of E
            // to figure value of array it uses
        }
    }
    return null;
}

请注意，尽管规范示例使用命名类，但相同的推理也适用于匿名类:

// ...
    for (int i = 0, i < 2; i++ ) { // loop to have several copies
        if (i == copy) {
            return new Enumeration() {
                int count = 0;
                public boolean hasMoreElements()
                    { return count < array.length; }
                public Object nextElement() {
                    { return array[count++]; }
            } // we hope to be done... oh no
        }

        array = null; // not final => can change
    }