匿名类、继承和重写

Question

public class A {
    public A() {
        foo();
    }

    private void foo() {
        System.out.print("A::foo ");
        goo();
    }

    public void goo() {
        System.out.print("A::goo ");
    }
}

public class B extends A {
public B() {
    foo();
}

public void foo() {
    System.out.print("B::foo ");
}

public void goo() {
    System.out.print("B::goo ");
}

    public static void main(String[] args) {

A b = new B() {
        public void foo() {System.out.print("Anonymous::foo ");}
        public void goo() {((B)this).foo();}
        };

}
}

我希望您帮助理解为什么程序打印 A::foo Anonymous::foo Anonymous::foo。这个匿名类是不是取代了之前的B？重写它的方法？

在我看来，它应该转到 A 的默认构造函数，运行 A 的 foo- print "A::foo"，而不是运行 B 的 goo，因为它已被正确覆盖，但现在 B 的 goo 是匿名类中的，所以它将其强制转换为 B （不执行任何操作），并运行 B 的 foo（即上面的 foo），因此它应该打印“Anonymous:foo”。我做错了什么？

多谢。

Answer 1

你的问题不太清楚，但我只想说，如果你有一个顶级类 C，而不是扩展 B 的匿名类，那么答案将完全相同 扩展 B。匿名类在多态性和继承方面的行为没有什么不同。当 B 的构造函数调用 foo() 时，将调用最派生类（此处为匿名类）中的重写版本。

Answer 2

我认为这里令人困惑的是你有两个 foo 方法。一个是私有的，因此不符合覆盖条件，另一个是公共的，因此可以被覆盖。 B 在其构造函数中调用 foo 但被其子类覆盖。

Answer 3

A 的构造函数调用 A.foo (A::foo)，因为它是私有的，因此不会重载。 A.foo 调用 goo() ，它被 B 覆盖，然后被 Anonymous 覆盖，所以你得到 Anonymous.goo -> Anonymous.foo（匿名::foo）。然后 B 的构造函数调用 foo ，它被 Anonymous 覆盖，所以 (Anonymous::foo)

Answer 4

使用这种匿名构造实际上创建了 B 的子类。您已使用在匿名类中提供的方法覆盖了 B 的方法，因此将使用这些方法。