这两个匿名声明有什么区别class

Question

我找不到这两个匿名声明之间的区别 class。

class Boo {
       Boo(String s) { }
       Boo() { }
    }
    class Bar extends Boo {
       Bar() { }
       Bar(String s) {super(s);}
       void zoo() {
           Boo f = new Boo() {                       // Line-1
               void method()
               {
                   System.out.println("Inside anonymous");
               }
           };
       }
    }

class Boo {
       Boo(String s) { }
       Boo() { }
    }
    class Bar extends Boo {
       Bar() { }
       Bar(String s) {super(s);}
       void zoo() {
           Boo f = new Boo("Random String") {         // Line-2
               void method()
               {
                   System.out.println("Inside anonymous");
               }
           };
       }
    }

在这里我的理解是，匿名 class 是 class Boo 的子 class，其实例由引用变量 f 多态引用。但是使用无参数构造函数（第 1 行）和参数化构造函数（第 2 行）有什么不同呢？

Answer 1

注意到 Boo 中定义了多个构造函数。

和

 Boo f = new Boo("Random String") {         // Line-2
               void method()
               {
                   System.out.println("Inside anonymous");
               }
           };

由于它是一个匿名的 class，并且立即提供了实施，因此没有人使用该字符串，并且该字符串传递在那里是多余的。

Answer 2

让我们在您的 class 中添加一些 "meat"，看看有什么区别。更改 Boo 以便它实际对字符串执行某些操作：

class Boo {
    private String s = "Default";

    Boo(String s) {
        this.s = s;
    }

    Boo() {
    }

    protected String getString() {
        return s;
    }
}

现在它存储字符串，任何子class 都可以通过getString() 方法检索该字符串。

现在展开我们的Bar:

class Bar extends Boo {
    Bar() {
    }

    Bar(String s) {
        super(s);
    }

    void zoo() {
        Boo anon1 = new Boo() {                       // Line-1
            void method()
            {
                System.out.println("Inside anonymous");
            }
            @Override
            public String toString() {
                return "First anonymous subclass of Boo with value " + getString();
            }
        };
        Boo anon2 = new Boo("Some Random Value") {    // Line-2
            void method()
            {
                System.out.println("Inside anonymous");
            }
            @Override
            public String toString() {
                return "Second anonymous subclass of Boo with value " + getString();
            }
        };
        System.out.println(anon1);
        System.out.println(anon2);
    }
}

所以我在同一个方法中创建了两种类型的匿名 classes，然后打印它们。请注意，我为每个匿名 classes 添加了一个 toString 方法。 toString 方法在 returns.

的值中使用 Boo 中的 getString

现在，当您调用 new Bar().zoo() 时会发生什么？

你得到了输出

First anonymous subclass of Boo with value Default
Second anonymous subclass of Boo with value Some Random Value

因此第一个对象 anon1 是使用 Boo 的无参数构造函数创建的。因此私有 s 的值为 Default。这反映在 toString() 方法中。第二个对象是用 Boo 的另一个构造函数创建的，它给 s 一个不同的值。现在该值成为打印值的一部分。

因此，当构造函数实际执行某些操作时，匿名 class 使用构造函数中传递的信息，那么是否传递参数会有所不同。

备注

Bar 本身也是 Boo 的子 class 但在您的示例中，它没有区别。可以是完全独立的class.
方法 method() 从未使用过，也不能使用（除了反射等），因为对匿名 class 的唯一引用是通过类型 Boo 而不是有一个可继承的method()。您不能从 superclass 引用调用 subclass 的方法，除非该方法被继承或覆盖。

这两个匿名声明有什么区别class

What is the difference between these two declaration of anonymous class

java

anonymous-inner-class