当一个没有引用其封闭类的匿名类从实例方法返回时，它有一个对 this 的引用。为什么？

考虑以下代码:

package so;

import java.lang.reflect.Field;

public class SOExample {

    private static Object getAnonymousClassFromStaticContext() {
        return new Object() {
        };
    }

    private Object getAnonymousClassFromInstanceContext() {
        return new Object() {
        };
    }

    public static void main(String[] args) throws NoSuchFieldException, SecurityException {

        Object anonymousClassFromStaticContext = getAnonymousClassFromStaticContext();
        Object anonymousClassFromInstanceContext = new SOExample().getAnonymousClassFromInstanceContext();

        Field[] fieldsFromAnonymousClassFromStaticContext = anonymousClassFromStaticContext.getClass().getDeclaredFields();
        Field[] fieldsFromAnonymousClassFromInstanceContext = anonymousClassFromInstanceContext.getClass().getDeclaredFields();

        System.out.println("Number of fields static context: " + fieldsFromAnonymousClassFromStaticContext.length);
        System.out.println("Number of fields instance context: " + fieldsFromAnonymousClassFromInstanceContext.length);
        System.out.println("Field from instance context: " + fieldsFromAnonymousClassFromInstanceContext[0]);

    }

}

这是输出:

Number of fields static context: 0
Number of fields instance context: 1
Field from instance context: final so.SOExample so.SOExample$2.this$0

虽然看似调用相同的代码，但每种方法都在做不同的事情。在我看来，实例方​​法返回一个嵌套类，而静态方法返回一个静态嵌套类(作为静态成员，它显然不能引用 this)。

鉴于没有对封闭类的引用，我看不出这样做有什么好处。

幕后发生了什么？

最佳答案

匿名/内部类背后有一个设计原则:内部类的每个实例都属于外部类的一个实例。

遗漏对内部类的引用会改变垃圾回收的行为:它的实现方式是，只要内部类还活着，外部类就不能被垃圾回收。
这支持了没有外部类就不能存在内部类的观点。

应用程序可能依赖于此行为，例如通过创建临时文件并在析构函数中将其删除。这样，只有当所有内部类都消失后，文件才会被删除。

这也意味着无法更改当前行为，因为更改它可能会破坏现有应用程序。

因此，当您不需要引用时，您应该始终将内部类标记为静态，因为这可能会导致一些不错的内存泄漏。

编辑: Example of what I am trying to say (对糟糕的代码质量感到抱歉):

class Ideone
{
    static Object[] objects = new Object[2];

    public static void main (String[] args) throws java.lang.Exception
    {
        M1();
        M2();
        System.gc();
    }

    static void M1() {
        objects[0] = new Foo().Bar();
    }
    static void M2() {
        objects[1] = new Foo().Baz();
    }
}

class Foo {
    static int i = 0;
    int j = i++;

    public Foo() {
        System.out.println("Constructed: " + j);
    }

    Object Bar() {
        return new Object() {

        };
    }
    static Object Baz() {
        return new Object() {

        };
    }

    protected void finalize() throws Throwable {
        System.out.println("Garbage collected " + j);
    }
}

输出:

Constructed: 0
Constructed: 1
Garbage collected 1

如您所见，第一个 Foo 未被垃圾回收，因为仍有一个“内部实例”处于 Activity 状态。要使此行为起作用，内部类需要一个引用。

当然，它也可以以不同的方式实现。但我要说的是，保留引用是有意做出的设计决定，因此“内部实例”不会比其父实例长寿。

顺便说一句:The Java language reference非常隐晦地说明了这一点(不访问外部类的内部类也不异常(exception)):

An instance i of a direct inner class C of a class or interface O is associated with an instance of O, known as the immediately enclosing instance of i. The immediately enclosing instance of an object, if any, is determined when the object is created (§15.9.2).

关于java - 当一个没有引用其封闭类的匿名类从实例方法返回时，它有一个对此的引用。为什么？，我们在Stack Overflow上找到一个类似的问题： https://stackoverflow.com/questions/34621640/