这两个匿名类声明之间有什么区别

Question

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

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");
               }
           };
       }
    }

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

Answer 1

• 它指出Boo定义了多个构造函数。

和

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

因为它是一个匿名类，并且立即提供了实现，所以没有人使用该字符串，并且在那里传递字符串是多余的。

Answer 2

让我们在类中添加一些“肉”，以了解它们之间的区别。 更改Boo以便它实际上对字符串起作用：

class Boo {
    private String s = "Default";

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

    Boo() {
    }

    protected String getString() {
        return s;
    }
}

现在，它存储了字符串，任何子类都可以通过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);
    }
}

因此，我在同一方法内创建了两种类型的匿名类，然后将它们打印出来。 请注意，我已经向每个匿名类添加了toString方法。 toString方法在返回的值中使用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的no-args构造函数创建的。 因此，private s值为Default 。 这反映在toString()方法中。 第二个对象是由Boo的另一个构造函数创建的，它赋予s一个不同的值。 现在，该值已成为打印值的一部分。

因此，当构造函数实际执行某项操作时，匿名类利用了在构造函数中传递的信息，那么无论是否传递参数，它都会有所不同。

笔记

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