为什么lambda和anonymous类有不同的隐式添加字段？

Question

public class AnonymousExample {

    private Runnable instanceRunnable = new Runnable() {
        @Override
        public void run() { }
    };

    private static Runnable staticRunnable = new Runnable() {
        @Override
        public void run() { }
    };

    public static void main(String[] args) throws IllegalAccessException {
        Runnable localRunnable = new Runnable() {
            @Override
            public void run() { }
        };
        System.out.println("-- local anonymous class --");
        print(localRunnable.getClass(), localRunnable);

        System.out.println("\n-- instance anonymous class --");
        AnonymousExample em = new AnonymousExample();
        print(em.instanceRunnable.getClass(), em.instanceRunnable);

        System.out.println("\n-- static member anonymous class --");
        print(staticRunnable.getClass(), staticRunnable);
    }

    public static void print(Class<?> c, Object instance) throws IllegalAccessException {
        System.out.println("- constructors -");
        for (Constructor<?> constructor : c.getDeclaredConstructors()) {
            System.out.println(constructor.toGenericString());
        }
        System.out.println("- fields -");
        for (Field field : c.getDeclaredFields()) {
            System.out.printf(" field name: %s,%n field type: %s,%n field value: %s%n",
                    field.getName(),
                    field.getType(),
                    field.get(instance));
        }
    }

}

-- local anonymous class --
- constructors -
field.AnonymousExample$3()
- fields -

-- instance anonymous class --
- constructors -
field.AnonymousExample$1(field.AnonymousExample)
- fields -
 field name: this$0,
 field type: class field.AnonymousExample,
 field value: field.AnonymousExample@79fc0f2f

-- static member anonymous class --
- constructors -
field.AnonymousExample$2()
- fields -

类来测试如何捕获lambda的字段

    public class CapturingLambdaExample {

    private int x = 10;
    private static int y = 20;

    private Runnable instanceRunnable = () -> { System.out.println(x);};
    private static Runnable staticRunnable = () -> { System.out.println(y);};

    public static void main(String[] args) throws IllegalAccessException {
        int z = 20;//effectively final
        Runnable localRunnable = () -> { System.out.println(z);};
        System.out.println("-- local capturing lambda --");
        print(localRunnable.getClass());

        System.out.println("\n-- instance capturing lambda --");
        CapturingLambdaExample em = new CapturingLambdaExample();
        print(em.instanceRunnable.getClass());

        System.out.println("\n-- static capturing lambda --");
        print(staticRunnable.getClass());
    }

    public static void print(Class<?> c) throws IllegalAccessException {
        System.out.println("- constructors -");
        for (Constructor<?> constructor : c.getDeclaredConstructors()) {
            System.out.println(constructor.toGenericString());
        }
        System.out.println("- fields -");
        for (Field field : c.getDeclaredFields()) {
            System.out.printf(" field name: %s,%n field type: %s,%n ",
                    field.getName(),
                    field.getType());
        }
    }

}

产出：

-- local capturing lambda --
- constructors -
private field.CapturingLambdaExample$$Lambda$15/0x0000000840065440(int)
- fields -
 field name: arg$1,
 field type: int,

-- instance capturing lambda --
- constructors -
private field.CapturingLambdaExample$$Lambda$25/0x0000000840068840(field.CapturingLambdaExample)
- fields -
 field name: arg$1,
 field type: class field.CapturingLambdaExample,

-- static capturing lambda --
- constructors -
private field.CapturingLambdaExample$$Lambda$14/0x0000000840064c40()
- fields -

Answer 1

匿名类和Lambda确实有一些不同。

>

匿名类可以扩展另一个类，也可以有多个方法。所以关键字，this和super需要分别用来访问它自己的成员和它的超类成员。此外，如果匿名类需要访问封闭类&封闭类的父成员，它必须使用限定的this和super关键字。示例:encursingClass.this.ToString()

另一方面，Lambda只能用一种方法实现一个接口。它没有其他成员，所以关键字this和super可以用来引用封闭类及其父类的成员。

public class EnclosingClass {

    public static void main(String[] args) {
        new EnclosingClass().start();
    }

    private void run(Runnable runnable) {
        runnable.run();
    }

    private void start() {
        System.out.println("--- Lambda ---");
        run(() -> {
            System.out.println(this.toString());
            System.out.println(super.toString()); // Use Object.toString
        });

        System.out.println("---Anonymous class---");
        run(new AnonymousSuperClass() {
            @Override
            public void run() {
                super.commonMethod();
                System.out.println(this.toString());
                System.out.println(super.toString());
                System.out.println(EnclosingClass.this.toString());
                System.out.println(EnclosingClass.super.toString()); // Use Object.toString
            }

            @Override
            public String toString() {
                return "Anonymous Class";
            }
        });
    }

    @Override
    public String toString() {
        return "Enclosing Class";
    }

    private static abstract class AnonymousSuperClass implements Runnable {
        protected void commonMethod() {
            System.out.println("Some common processing");
        }

        @Override
        public String toString() {
            return "Anonymous Super Class";
        }
    }
}

--- Lambda ---
Enclosing Class
EnclosingClass@eed1f14
---Anonymous class---
Some common processing
Anonymous Class
Anonymous Super Class
Enclosing Class
EnclosingClass@eed1f14

为什么本地捕获lambda需要隐式添加字段，而匿名类不需要？这不是真的。在您的示例中，匿名类没有使用封闭方法中的任何字段。

对于下面的代码片段，

private static void start() throws IllegalAccessException {
        int x = 5;
        System.out.println("---- Anonymous class ----");
        print(new Runnable() {

            @Override
            public void run() {
                System.out.println(x);
            }
        }.getClass());

        System.out.println("---- Lambda class ----");
        Runnable r = () -> System.out.println(x);
        print(r.getClass());
    }

这是输出：

---- Anonymous class ----
- constructors -
EnclosingClassV2$1(int)
- fields -
 field name: val$x,
 field type: int,
 ---- Lambda class ----
- constructors -
private EnclosingClassV2$$Lambda$1/455659002(int)
- fields -
 field name: arg$1,
 field type: int,

null