Java——静态和动态类型——“这打印什么？”

Question

所以我在理解这个在课堂上展示的例子时遇到了一些麻烦——它应该说明 Java 中静态和动态类型之间的微妙之处。

public class Piece {

    public static void main (String[] args) {
        Piece p2 = new Knight();
        Knight p1 = new Knight();
        p1.capture(p2); // call 1; "Knight is bored" is supposed to be printed
        p2.capture(p1); // call 2; "knight is bored" is supposed to be printed
    }

    public void capture () {
        System.out.println("Capturing");
    }

    public void capture (Piece p) {
        System.out.println("I'm bored")
    }

public class Knight extends Piece {

    public void capture (Piece p) {
        System.out.println("Knight is bored");
    }

    public void capture (Knight k) {
        System.out.println("TOO SLOW BUDDY");
    }
}

以下是我对拨打这两个电话时发生的情况的理解：

调用 1：p1.capture(p2)

从 p1 调用捕获方法。通过动态类型查找，它看到 p1 的动态类型是 Knight。所以它看起来在 Knight 子类中。 p2 作为参数传入。要查看在 Knight 子类中调用哪个捕获方法，它会检查 p2 的 static 类型，即 piece。因此，打印了“Knight is Bored”。这是正确的输出，但我的推理是否正确？

调用 2：p2.capture(p1)

使用相同的推理，从 p2 调用捕获方法。通过动态类型查找，发现p2的动态类型是Knight。所以它看起来在 Knight 子类中。 p1 作为参数传入。要查看调用哪个捕获方法，它会查看 p1 的静态类型，即 Knight。因此，打印“TOO SLOW BUDDY”。显然，我的推理是错误的，因为这不是真正印出来的。有什么方向吗？

谢谢！

Answer 1

我记得，我知道“扩展”是指“将新的覆盖旧的但不删除它”，如果您“覆盖”该方法，它会像您描述的那样。 在您的情况下，如果您调用“p1.capture(p1)”，它应该会导致“TOO SLOW BUDDY”（但我没有尝试过）。

Answer 2

我不认为这个示例告诉您 static 和 dynamic type 之间的区别。你甚至不需要考虑超类和子类。它只是告诉你方法定义。 ---> 只有当调用者、方法名、参数名和参数类型都相同时，才会调用正确的方法。

Answer 3

在第二次调用中，只能调用 Piece 类的方法或其子类中的相同方法。这就是为什么它会调用 capture(Piece p) 而不是 capture(Knight k)。后者是特定于骑士类的。

例如，当我们有“List a = new Arraylist();”时，您只能调用在 List 中声明的方法，而不是在 ArrayList 中附加但外观相似的方法。

Answer 4

当您将@Override 注释添加到Knights 方法时，它会变得清晰。

public void capture (Knight k) {
    System.out.println("TOO SLOW BUDDY");
}

此方法未被覆盖 - 它是新方法，已添加到 Knight 类中。

因此它只能用于Knight 类型的对象 - 例如：Knight k = new Knight();

您没有这样的示例，即在 Knight 上以 Knight 作为参数调用此方法。你在 Knight with Piece 和 Piece with knight 上调用了capture

    p1.capture(p2); // call 1; "Knight is bored" is supposed to be printed
    p2.capture(p1); // call 2; "knight is bored" is supposed to be printed
    p1.capture(p1); // call 3:  TOO SLOW BUDDY <- look here :)

Answer 5

 p2.capture(p1); // call 2; "knight is bored" is supposed to be printed

在这里，您正在调用 Piece 类对象的捕获方法，并且由于您已通过 p1(Knight) 类引用，它将调用 Knight 类的重写捕获方法。那就是

 public void capture (Piece p) {
        System.out.println("Knight is bored");
    }

Answer 6

如果你运行以下代码 -

public class Piece {

public static void main (String[] args) {
    Piece p2 = new Knight();
    Knight p1 = new Knight();
    p1.capture(p2); 
    p2.capture(p1); 
}

public void capture () {
    System.out.println("Capturing");
}

public void capture (Piece p) {
    System.out.println("I'm bored");
}

}

  class Knight extends Piece {


  //    public void capture (Piece p) {
  //        System.out.println("Knight is bored");
  //    }

public void capture (Knight k) {
    System.out.println("TOO SLOW BUDDY"+k);
}

}

结果是——

我很无聊

我很无聊

所以动态查找检查子类是否覆盖了函数。