编译时与运行时多态（或方法签名）的行为(Behaviour of compile-time vs run-time polymorphism (or method signature))

 我有以下用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或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示例有如此不同？ 谢谢。 

I have the following illustrative code written in Java. It shows the overriding of the introduceYourself() method for the different bikes.
 
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.");
    }
}
 
Just as I was expecting, the following code calls the introduceYourself() method for each run-time object, although the variables were declared as the base Bicycle class. This would be useful if I were to add Bicycle or Bicycle subtype objects to an array and call the method on a loop.
 
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.  
     }
}
 
 
However, I am having trouble understanding the behaviour of this other code. I have the following classes which, again, show inheritance, but methods with different signatures (overloading):
 
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);
    }
}
 
And the following code in the main method:
 
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
 }
 
}
 
Why does the object referenced by a1 (with declared type A and run-time type D) call the method declared in A instead of the most-appropiate one (by signature) known by its runtime object of class D? (Also, I suppose there is an automated casting, since the argument type is not the same.) Why does it seem to behave so differently from the Bicycle example? Thanks.

原文：https://stackoverflow.com/questions/36144773