Java 这两个匿名类声明之间有什么区别_Java_Anonymous Inner Class

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

java

Java 这两个匿名类声明之间有什么区别,java,anonymous-inner-class,Java,Anonymous Inner 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

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

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

这里我理解的是，匿名类是类

Boo

的子类，其实例由引用变量

多态引用。但是使用无参数构造函数（第1行）和参数化构造函数（第2行）有什么区别呢

它注意到，
```
Boo
```
中定义了多个构造函数

及

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

它注意到，
```
Boo
```
中定义了多个构造函数

及

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

让我们向类中添加一些“肉”，看看有什么区别。更改

Boo

，使其实际处理字符串：

class Boo {
    private String s = "Default";

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

    Boo() {
    }

    protected String getString() {
        return s;
    }
}

现在它存储字符串，任何子类都可以通过

getString（）

方法检索该字符串

现在展开我们的

栏

：

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

现在，调用

newbar（）.zoo（）

时会发生什么

你得到了输出

First anonymous subclass of Boo with value Default Second anonymous subclass of Boo with value Some Random Value 具有默认值的Boo的第一个匿名子类具有随机值的Boo的第二个匿名子类因此，第一个对象，

anon1

是使用

Boo

的无参数构造函数创建的。因此，私有

具有值

Default

。这反映在

toString（）

方法中。第二个对象是用

Boo

的另一个构造函数创建的，它给

一个不同的值。现在，该值成为打印值的一部分

因此，当构造函数实际执行某些操作，并且匿名类使用在构造函数中传递的信息时，如果您传递参数与否，则会产生不同

注释

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

让我们在您的类中添加一些“肉”，看看有什么不同。更改Boo
，使其实际处理字符串：
class Boo {
    private String s = "Default";

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

    Boo() {
    }

    protected String getString() {
        return s;
    }
}

现在它存储字符串，任何子类都可以通过getString（）
方法检索该字符串
现在展开我们的栏
：
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

现在，调用newbar（）.zoo（）
时会发生什么
你得到了输出
First anonymous subclass of Boo with value Default
Second anonymous subclass of Boo with value Some Random Value
具有默认值的Boo的第一个匿名子类
具有随机值的Boo的第二个匿名子类
因此，第一个对象，anon1
是使用Boo
的无参数构造函数创建的。因此，私有s
具有值Default
。这反映在toString（）
方法中。第二个对象是用Boo
的另一个构造函数创建的，它给s
一个不同的值。现在，该值成为打印值的一部分
因此，当构造函数实际执行某些操作，并且匿名类使用在构造函数中传递的信息时，如果您传递参数与否，则会产生不同
注释

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

如果Boo
在其构造函数中没有做任何事情，则不会太多。也许你应该在Boo
构造函数中添加一些“肉”。@realpoint“如果Boo在其构造函数中没有做任何事情，那么就不要太多了”你可以通过建议一个场景来详细说明这个plz，当它起作用时。如果Boo
在其构造函数中没有做任何事情，那么就不要太多了。也许你应该在Boo
构造函数中添加一些“肉”。@realponsust“如果Boo在其构造函数中没有做任何事情，那么就不会太多了”你可以通过建议一个场景来详细说明这个plz，当它起作用时。这意味着我们可以在创建匿名类时使用任何可用的构造函数。这没什么区别？我们可以使用任何构造函数，如果它可用的话。这意味着我们可以在创建匿名类时使用任何可用的构造函数。这没什么区别吗？我们可以使用任何构造函数，如果它可用的话。这完全有道理：）这完全有道理……）