Java动态绑定(bind)和方法重写过程

Question

我大概知道静态绑定(bind)发生在编译时而动态绑定(bind)发生在运行时的原理。我已经阅读了几个相关问题。我可以跟上他们中许多人的思路，但是当我遇到如下具体问题时，我又搞砸了，失去了逻辑:

class Cake {
    public void taste (Cake c) {
        System.out.println("In taste of Cake class");
    }
}

class ChocolateCake extends Cake {
    public void taste(Cake c) {
        System.out.println("In taste (Cake version) of ChocolateCake class");
    }
    public void taste(ChocolateCake cc) {
        System.out.println("In taste (ChocolateCake version) of ChocolateCake class");
    }
}

class BirthdayCake extends ChocolateCake {
    public void taste(Cake c) {
        System.out.println("In taste (Cake version) of BirthdayCake class");
    }
    public void taste (ChocolateCake cc) {
        System.out.println("In taste (ChocolateCake version) of BirthdayCake class");
    }
    public void taste(BirthdayCake bc) {
        System.out.println("In taste (BirthdayCake version) of BirthdayCake class");
    }
}

已创建以下对象:

Cake c1 = new Cake();
ChocolateCake cc = new ChocolateCake();
Cake c2 = new ChocolateCake();
Cake c3 = new BirthdayCake();

输出如下所示:

c1.taste(cc);//Output: In taste of Cake class
cc.taste(cc);//Output: In taste (ChocolateCake version) of ChocolateCake class
c2.taste(cc);//Output: In taste (Cake version) of ChocolateCake class
((BirthdayCake) c3).taste(cc);//Output: In taste (ChocolateCake version) of BirthdayCake class
((BirthdayCake) c3).taste((BirthdayCake) c3);//Output: In taste (BirthdayCake  version) of BirthdayCake class

基本上，我的问题是为什么c2.taste(cc)调用ChocolateCake类中的taste(Cake c)方法？

这是我的想法: c2 的静态类型是 Cake，它决定将调用 Cake 中的方法。在运行时，c2的动态类型，即ChocolateCake，决定了调用ChocolateCake cake中的方法。由于其参数类型为 ChocolateCake，因此最终将调用 taste(ChocolateCake cc)。

显然，这种想法是错误的。如果我假设该方法的签名是在编译时确定的，因为 c2 的静态类型是 Cake 并且类 Cake 中只有一个方法。当涉及到运行时时，它将调用类 ChocolateCake 中的重写方法。整个事情有点有意义。我的困惑是为什么它会这样工作而不是以前的方式？

另一件事我不明白的是，我们不允许编写如下所示的语句，因为它会出现编译错误:

ChocolateCake cc = new Cake();。

但是为什么 ChocolateCake 类型引用最终可以传递 Cake 对象，因为它应该调用 ChocolateCake 类中的 taste(Cake c) 方法来获得如上所述的正确输出。

我想我仍然不明白在对象引用上调用方法的整个过程。就像在编译时决定最佳匹配方法时发生的情况以及之后发生的情况一样，比方说，运行时(我不确定此过程中是否还有任何其他阶段)。

谁能帮忙说明一下这个过程吗？ 非常感谢!

Answer 1

让我尝试简化示例并完成这些步骤。为了清楚起见，我还添加了 @Override。

class Cake {
    public void taste (Cake c) {
        System.out.println("In taste of Cake class");
    }
}

class ChocolateCake extends Cake {
    @Override
    public void taste(Cake c) {
        System.out.println("In taste (Cake version) of ChocolateCake class");
    }
    public void taste(ChocolateCake cc) {
        System.out.println("In taste (ChocolateCake version) of ChocolateCake class");
    }
}

ChocolateCake param = new ChocolateCake();    
Cake cake = new ChocolateCake();
cake.taste(param);

当您调用cake.taste(param);时java编译器根据引用的类型而不是引用指向的实际对象类型来选择编译时调用哪个方法。

cake的引用类型是 Cake ，因此编译器会查找基类 Cake对于名为 taste 的方法并接受Cake作为参数。自 ChocolateCake是 Cake (通过继承)编译器找到匹配项。

因为本质上你可以覆盖基 taste方法，在运行时期间，由于动态调度，JVM 解析 cake 的实际类型。引用，即ChocolateType并调用已选择方法的覆盖。