关于java：当从实例方法返回一个没有引用其封闭类的匿名类时，它会引用它。


When an anonymous class with no references to its enclosing class is returned from an instance method, it has a reference to this. Why?

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

考虑以下代码：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
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]);

    }

}

这是输出：

1
2
3
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)。

考虑到没有引用封闭类这一事实，我看不到其中的好处。

幕后发生了什么？

相关讨论

  • 这就是闭包不这样做的原因。我假设这样简化了实现，以避免在实际不需要的情况下优化离开this或外部类。
  • 考虑到没有对封闭类的引用这一事实，您的意思是什么？
  • stackoverflow.com/a/1353326/2680506
  • @我的意思是，在实例方法中，在返回的匿名类中，我们没有说类似于SOExample.this.someField ="foo"的内容。
  • @robertbain引用仍然存在，这与匿名类中的private SOExample foobar成员初始化为外部实例非常相似——即使没有使用它的代码，它仍然存在。引用外部实例是因为Java规范说它是这样的——即使没有使用它的代码，也没有特殊的情况省略了引用。
  • 这适用于所有本地类，而不仅仅是匿名类。老实说，我不认为让在非静态内容中创建的本地类可以访问外部类的其他成员有什么奇怪的(并且为了使它成为可能，它需要引用，它将保存外部类的特定实例)。在静态上下文中创建的本地类对实例一无所知，因此它们不需要字段来保存此类实例。

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

省略对内部类的引用会改变垃圾收集的行为：按照实现方法，只要内部类是活动的，就不能对外部类进行垃圾收集。这支持了这样一种观点：没有外部类，内部类就不可能存在。

应用程序可能依赖于这种行为，例如通过创建一个临时文件并在析构函数中删除它。这样，只有当所有内部类都不存在时，文件才会被删除。

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

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

编辑：我想说的示例(对糟糕的代码质量表示抱歉)：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
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不是垃圾收集的，因为仍然有一个"内部实例"处于活动状态。要使此行为正常工作，内部类需要一个引用。

当然，它也可以以不同的方式实现。但是我要说的是，保持引用是一个故意作出的设计决策，这样"内部实例"就不会比它的父实例寿命长。

顺便说一句：Java语言引用很神秘地说明了这一点(对于不访问外部类的内部类没有例外)：

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

相关讨论

  • 我一定是错过了什么，但从我收集到的信息来看，你所说的话和我提出的问题是一样的。如果没有对封闭类的引用，那么实例方法最好返回Object，而不引用this，即静态嵌套类。
  • 不。在这种情况下(返回静态嵌套类)，保持活动状态返回的实例(在其他地方)将不会保持活动的外部类。如果返回一个内部类将。我将尝试添加一个示例。
  • 添加示例。我希望它有助于澄清问题。
  • +1表示"当然，它也可以以不同的方式实施。但是我要说的是，保持引用是一个有目的的设计决策，这样"内部实例"就不会比它的父实例寿命长，"在特定的情况下寻找小的微观优化，当有一个更大的设计模式在起作用时似乎没有效果。
  • 你不能从这件事情中得出任何结论。这个方法可以调用，也可以不调用，你永远不知道…
  • 问题是：一旦在任何时候以这种方式实现了它，就不能因为向后兼容性而更改它。因此，优化可能实际上对99%的应用程序有益，但是由于1%的应用程序将被破坏，所以我们坚持这种行为。依我看，依赖这种行为将是编写Java代码的一种可怕方式。
  • @马可13：一般来说是这样。但是，在这种情况下，幸运地调用了一个foo实例的finalize，并且由于上述引用，将永远不会调用另一个foo实例。所以这个例子在说明我所说的方面仍然有效。但我同意：绝对不要依赖这种行为：—)

我只想说：它引用了this，因为它可能需要它。

想象一下对程序的一个微小修改：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
public class SOExample
{
    private static Object getAnonymousClassFromStaticContext()
    {
        return new Object()
        {
            @Override
            public String toString()
            {
                // ERROR:
                //"No enclosing instance of the type SOExample is accessible in scope"
                return SOExample.this.toString();
            }
        };
    }

    private Object getAnonymousClassFromInstanceContext()
    {
        return new Object()
        {
            @Override
            public String toString()
            {
                // Fine
                return SOExample.this.toString();
            }
        };
    }
}

显然，在实例上下文中创建的对象需要引用this，因为它必须能够访问封闭实例的方法(或字段，如果存在的话)。

在最初的示例中，您没有以任何方式访问封闭实例，这并不意味着默认情况下该this引用不存在。

在哪一点上，应该以其他方式作出决定？编译器是否应该检查this引用是否确实是必需的，如果不是，则将其丢弃？如果不需要this，那么创建一个静态内部类(或从静态上下文创建这个实例)。对封闭实例的引用只是内部类的实现方式。

by the way:The comparison with equalwill return false，even for two objects that are both created from the same"context"，if you don't implement your own equalsmethod in the returned objects respondly.>sub>

相关讨论

  • 很好，圣诞假期对我打击很大！)：移除。

即使我们看不到任何可见的引用，它仍然存在。请参见下面的代码。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
package jetty;

import java.lang.reflect.Constructor;
import java.lang.reflect.Modifier;
import java.util.Arrays;

public class SOExample2 {

    private static Object staticField = new Object () { };
    private Object nonStaticField = new Object () { };

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

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

    public static void main(String[] args) throws NoSuchFieldException, SecurityException {
        System.out.println("Started");

        class StaticMethodLocal {

        }

        System.out.println("############## Fields ##############");
        printClassInfo(staticField.getClass());
        printClassInfo(new SOExample2().nonStaticField.getClass());

        System.out.println("############## Methods ##############");
        printClassInfo(getAnonStatic().getClass());
        printClassInfo(new SOExample2().getAnonNonStatic().getClass());

        System.out.println("############## Method Local ##############");
        printClassInfo(new StaticMethodLocal().getClass());
        printClassInfo(new SOExample2().getNonStaticMethodLocal().getClass());
    }

    public static <T>void printClassInfo(Class<T> klass) {
        System.out.println("Class :" + klass);
        String prefix ="\t";

        System.out.println(prefix +"Number fields :" + klass.getDeclaredFields().length);
        if(klass.getDeclaredFields().length > 0) {
            System.out.println(prefix +"fields :" + Arrays.toString(klass.getDeclaredFields()));
        } else {
            System.out.println(prefix +"no fields");
        }
        System.out.println(prefix +"modifiers :" + Modifier.toString(klass.getModifiers()));

        //Constructors
        Constructor<?>[] constructors = klass.getDeclaredConstructors();
        for(Constructor<?> constructor : constructors) {
            System.out.println(prefix +"constructor modifiers :" + Modifier.toString(constructor.getModifiers()));
            System.out.println(prefix +"constructor parameters :" + Arrays.toString(constructor.getParameterTypes()));
        }
        System.out.println("");
    }

    private Object getNonStaticMethodLocal () {
        class NonStaticMethodLocal {
        }
        return new NonStaticMethodLocal();
    }
}

输出：

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
Started
############## Fields ##############
Class : class jetty.SOExample2$1
    Number fields : 0
    no fields
    modifiers :
    constructor modifiers :
    constructor parameters : []

Class : class jetty.SOExample2$2
    Number fields : 1
    fields : [final jetty.SOExample2 jetty.SOExample2$2.this$0]
    modifiers :
    constructor modifiers :
    constructor parameters : [class jetty.SOExample2]

############## Methods ##############
Class : class jetty.SOExample2$3
    Number fields : 0
    no fields
    modifiers :
    constructor modifiers :
    constructor parameters : []

Class : class jetty.SOExample2$4
    Number fields : 1
    fields : [final jetty.SOExample2 jetty.SOExample2$4.this$0]
    modifiers :
    constructor modifiers :
    constructor parameters : [class jetty.SOExample2]

############## Method Local ##############
Class : class jetty.SOExample2$1StaticMethodLocal
    Number fields : 0
    no fields
    modifiers :
    constructor modifiers :
    constructor parameters : []

Class : class jetty.SOExample2$1NonStaticMethodLocal
    Number fields : 1
    fields : [final jetty.SOExample2 jetty.SOExample2$1NonStaticMethodLocal.this$0]
    modifiers :
    constructor modifiers :
    constructor parameters : [class jetty.SOExample2]

我还添加了两种匿名类作为字段值和两种方法局部类。

显然，在非静态上下文中生成的类只有一个构造函数，而这个构造函数有一个封闭类类型的参数。

正如输出所建议的那样，在创建匿名/方法本地类时，JVM添加了一些额外的代码来保存封闭类实例引用。

这也可以在反编译器输出中看到。

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
    // Decompiled by Jad v1.5.8g. Copyright 2001 Pavel Kouznetsov.
// Jad home page: http://www.kpdus.com/jad.html
// Decompiler options: packimports(3)
// Source File Name:   SOExample2.java

//Static field anonynmouse class
class SOExample2$1
{
    SOExample2$1()
    {
    }
}

//Non static field anonynmouse class
class SOExample2$2
{
    final SOExample2 this$0;
    SOExample2$2()
    {
        this$0 = SOExample2.this;
        super();
    }
}

//static method anonynmouse class
class SOExample2$3
{
    SOExample2$3()
    {
    }
}

//Non static method anonynmouse class
class SOExample2$4
{
    final SOExample2 this$0;
    SOExample2$4()
    {
        this$0 = SOExample2.this;
        super();
    }
}

//Static method local class
class SOExample2$1StaticMethodLocal
{
    SOExample2$1StaticMethodLocal()
    {
    }
}

//Non static method local class
class SOExample2$1NonStaticMethodLocal
{
    final SOExample2 this$0;
    SOExample2$1NonStaticMethodLocal()
    {
        this$0 = SOExample2.this;
        super();
    }
}

结论：

  • 编译器在生成我们看不到的类文件时会做一些事情。例如，向类中添加一个default constructor或向一个没有显式调用任何this()自构造函数或super()构造函数的构造函数中添加一个默认的超类构造函数super()调用。对于添加封闭类型的引用也是如此，这里没有魔力。我们可以很容易地定义这样一个类，编译器只是通过为我们这样做让我们的生活更容易。
  • 这与编写自己的字节代码的方式相同。因此，绕过编译器本身，我们就可以做到这一点，而实际语言却做不到。
  • 由于匿名类中没有modifier输出，可以得出结论，它们只是方法局部类(所有类修饰符public、protected、private、abstract、static)在方法中失去意义。它们只是以方法局部类的名义被称为匿名类。