java - 编译时多态性与运行时多态性(或方法签名)的行为

Question

我有以下用 Java 编写的说明性代码。它显示了不同自行车的 introduceYourself() 方法的重写。

public class Bicycle{
    public void introduceYourself(){
        System.out.println("Hello I am just a bicycle.");
    }
}

public class MountainBike extends Bicycle{
    public void introduceYourself(){
        System.out.println("Hello I am a mountain bike and I love going outdoors.");
    }
}

public class CityBike extends Bicycle{
    public void introduceYourself(){
        System.out.println("My name is city bike and I prefer calm trips.");
    }
}

正如我所期望的，以下代码为每个运行时对象调用 introduceYourself() 方法，尽管变量被声明为基 自行车类。如果我要将 Bicycle 或 Bicycle 子类型对象添加到数组并循环调用该方法，这将很有用。

public class HelloWorld{

     public static void main(String []args){
        Bicycle b1 = new Bicycle();
        Bicycle b2 = new MountainBike();
        Bicycle b3 = new CityBike();

        b1.introduceYourself(); // Output: Hello I am just a bicycle.       
        b2.introduceYourself(); // Output: Hello I am a mountain bike and I love going outdoors.
        b3.introduceYourself(); // Output: My name is city bike and I prefer calm trips.  
     }
}

<小时/>

但是，我无法理解其他代码的行为。我有以下类，它们再次显示继承，但方法具有不同的签名(重载):

public class A{
    public int calc (double num){
    return (int)(num + 1);
    }
}

public class B extends A{
    public int calc (long num){
        return (int)(num + 2);
    }
}

public class C extends B{
    public int calc (int num){
        return (num + 3);
    }
}

public class D extends C{
    public int calc (float num){
        return (int)(num + 4);
    }
}

在main方法中添加以下代码:

public class HelloWorld{
 public static void main(String []args){
    int num1 = 10;
    long num2 = 10;

    A a1 = new D();
    D d1 = new D();

    System.out.println(a1.calc(num1)); // Output: 11
    System.out.println(a1.calc(num2)); // Output: 11

    System.out.println(d1.calc(num1)); // Output: 13
    System.out.println(d1.calc(num2)); // Output: 12
 }

}

为什么a1引用的对象(声明类型A和运行时类型D)调用中声明的方法>A 而不是类 D 的运行时对象已知的最合适的(通过签名)？ (另外，我认为存在自动转换，因为参数类型不同。)为什么它的行为似乎与 Bicycle 示例如此不同？谢谢。

Answer 1

只有当你重写时，多态才会起作用。在这里，您重载了不同的方法，因此当您声明时:

 A a1 = D();  

记住，父类对子类的方法一无所知，但子类知道父类的方法。所以这里你可以用D代替A，但你不能调用D的方法。抱歉，如果我的英语很糟糕，但是 TLDR:A 只知道 1 种方法 calc(double num) 并且因为 double num 也可以接受 int 和 long，这就是该函数起作用的原因。否则就行不通。

假设在第一个示例中，您在类 CityBike 中有一个方法 importYourSelf(String name) 并且执行如下操作:

 Bicycle bike = new CityBike();
 bike.introduceYourSelf("I'm a city bike"); //error - Bicycle does not have method with argument string