重载和多态性

Question

我希望有人能解释我是如何做出这个决定的。 我理解，根据声明的类型选择重载版本，但为什么在第二次调用时，根据运行时类型做出决定？

    public class Test {
        public static void main(String[] args) {
            Parent polymorphicInstance = new Child();

            TestPolymorphicCall tp = new TestPolymorphicCall();
            tp.doSomething(polymorphicInstance);
            // outputs: Parent: doing something... 

            call(polymorphicInstance);
            // outputs: Child: I'm doing something too 
        }
        public static void call(Parent parent){
            parent.doSomething();
        }
        public static void call(Child child){
            child.doSomething();
        }
    }

    public class Parent {
        public void doSomething() {
            System.out.println("Parent: doing something...");
        }
    }
    public class Child extends Parent{
        @Override
        public void doSomething() {
            System.out.println("Child: I'm doing something too"); 
        }
    }

    public class TestPolymorphicCall {
        public void doSomething(Parent p) {
            System.out.println("Parent: doing something...");
        }
        public void doSomething(Child c) {
            System.out.println("Child: doing something...");
        }
    }

提前致谢！

Answer 1

您的Parent类引用引用Child类对象：

Parent polymorphicInstance = new Child();

因此，当您在call方法中传递引用时，调用的实际方法是仅具有Parent参数类型的方法。 但是当你在父引用上调用方法doSomething() ：

public static void call(Parent parent){
    parent.doSomething();
}

它将调用doSomething()方法，您已在Child类中重写。

---

这是多态性的经典案例。 假设您有一个类Shape和一个子类Circle ，它会覆盖Shape类中定义的calculateArea()方法。

Shape circle = new Circle();
// This will invoke the method in SubClass.
System.out.println(circle.calculateArea());

当您在子类中覆盖超类方法时，将根据您的超类引用指向的实际对象在运行时决定调用的实际方法。 这称为方法调用的动态调度 。