Question

我试图理解多态性的概念。我听不懂以下句子：

我们可以一致地请求行为，而无需了解对象的完整类

这本书显示了一个示例代码，其中显示了三个类，然后创建超类的引用，然后使用该引用来调用派生类方法，这是实现多态性的常用技术，如下所示：

class B extends A{
void callme(){
System.out.println(“Inside B’s callme method”);
  }
}  //Q. What can you say about callme( )?
class C extends A {
void callme(){
System.out.println(“Inside C’s callme method”);
  }
}
class Dispatch {
public static void main(String args[ ]) {   
A a = new A(); //obj of Type A
B b = new B(); //obj of Type B
C c  = new C(); //obj of Type C
A r;
r = a; // r refers to an A object
r.callme();

r = b;//r refers to a B object
r.callme();  
r = c;// r refers to a C object
r.callme();
  }
}

请有人指导我：“为什么我们说我们没有关于完整对象类的信息”？构造函数可以告诉我们有关该类的信息。所有的类也在这里列出。什么是真实情况？

Answer 1

让我们举一个例子，其中通用类名A，B和C更加“真实”：

public class Dispatcher {
    public static void main(String[] args) {
        Animal a = new Animal();
        Animal b = new Dog();
        Animal c = new Cat();

        a.makeSound(); // prints "Generic animal sound"
        b.makeSound(); // prints "Woof!"
        c.makeSound(); // prints "Meow~~"

        //b.chaseBall() wouldn't work
        //c.purr() wouldn't work
    }


    static class Animal {
        public void makeSound() {
            System.out.println("Generic animal sound");
        }
    }

    static class Dog extends Animal {
        @Override
        public void makeSound() {
            System.out.println("Woof!");
        }

        public void chaseBall() {
            System.out.println("*goes chasing the ball*");
        }
    }

    static class Cat extends Animal {
        @Override
        public void makeSound() {
            System.out.println("Meow~~");
        }

        public void purr() {
            System.out.println("purrrrrr");
        }
    }
}

在main方法的第一行中，声明了三个变量，它们都是Animal类型，尽管第二个变量实际上是Dog类型，而第三个变量是Cat类型。但是由于它们现在被声明为动物类型，因此所有这些信息都知道：它们是动物。

这就是为什么在所有这些对象上调用makeSound（）的原因：我们可以一致地请求（动物）的行为，而无需知道对象的完整类（如Dog或Cat）。

但是由于b（一只狗）和c（一只猫）现在已被声明为动物，因此它们不能具有与这些类型相对应的调用方法（例如chaseBall（）和purr（））。

多态性：在不知道对象完整类的情况下一致地请求行为

1 个答案: