Java 运行时多态性

输出：

class A {
    public void display(){
        System.out.println("From Class A");
    }
}

class B extends A {
    public void display() {
        System.out.println("From Class B");
    }
}

public class Test {
    public static void main(Strings[] args){

        A a = new A();
        A b = new B()
        a.display();
        b.display();
    }
}

现在，我得到了预期的输出。 但是我想知道为什么我使用

ab=new b（）

，而使用

B=new B（）

---

使用前一种技术的好处是什么，何时何地对我有益？

让我们举个例子。我们都知道鸟会飞，但也有一些例外。我们从他们的行为中知道，所以让我们对此进行建模

一般来说，鸟类会飞，因此：

From Class A    
From Class B

我们都知道鸭子不会飞，但我们并不是说所有的鸟都会飞。我们在运行时说一只特定的鸟是否能飞，这取决于鸟

class Bird {
  void fly() {
      System.out.println("I can fly");
    }
 }

class Eagle extends Bird {
      void fly() {
        System.out.println("I can fly very high");
    }
}

---

你可以看到，在运行时，鸭子不能飞。你可以忽略它的飞行行为，它可以行走或游泳。我们看到鸭子是一种鸟，它不会飞，所以我们忽略了它的行为，鸭子仍然是一种鸟，它可以走路或游泳。

在您的示例中，您选择哪种方式并不重要。您的示例没有显示多态性的威力

让我们看一个简单的多态性示例：

矩形

、

三角形

和

圆形

只是实现了它们自己对

绘图

函数的定义

现在，假设您必须在

Main

类中实现一个

drawAllShapes

方法，它接受一组形状并将它们全部打印出来。但是如果没有多态性，这可能会非常繁忙，因为可能会有不同类型的形状。现在，多态性来拯救我们了

interface Shape{
    void draw();
}

class Rectangle implements Shape{
    public void draw(){
        System.out.println("Drawing Rectangle.");
    }
}

class Triangle implements Shape{
    public void draw(){
        System.out.println("Drawing Triangle.");
    }
}

class Circle implements Shape{
    public void draw(){
        System.out.println("Drawing Circle.");
    }
}

类随机形状因子{
公共静态形状createRandomShape（）{
形状随机形状；
随机=新随机（）；
int randomNo=random.nextInt（）%3+1；
如果（随机数=1）{
randomShape=新矩形（）；
}
else if（randomNo==2）{
randomShape=新三角形（）；
}
否则{
随机形状=新圆（）；
}
返回随机形状；
}
}
班长{
公共静态void main（字符串[]args）{
形状[]形状=新形状[10]；
对于（int i=0；i

drawAllShapes

的这种实现不必知道索引

i

处的

Shape

是否是

圆

或

三角形

或其他什么，无论

Shape

是什么，它只调用

draw

方法的实现

main

方法具有所有随机形状，当传递给

drawAllShapes

方法时，将调用它们的相关实现

这种实现也遵循这样的原则，即如果您希望在将来向层次结构添加更多的形状，

drawAllShapes

方法也不必知道新的形状，只需添加新类并实现

Shape

接口，

drawAllShapes

也可以处理这些形状

---

参见上面的示例。

参见-不完全是您所问的问题，但您应该会发现答案很有启发性。还可以查看以下讨论：.Irfan@What's write-What-mist-in-like:Duck Duck=new Duck（）；鸭。飞（）；我不会实现同样的功能。没有什么错，但这不是多态的。Bird在运行时决定应该分配哪个行为，一只鸭子、一只鹰还是一只鸟。你的答案更多的是软件设计原则和模式，而不是运行时多态性的基本原则。我想，问题是，为什么要使用基类引用，并调用运行时多态性原则，而不是使用实际类本身的引用。所以我试着用一个例子来展示多态性的威力。

interface Shape{
    void draw();
}

class Rectangle implements Shape{
    public void draw(){
        System.out.println("Drawing Rectangle.");
    }
}

class Triangle implements Shape{
    public void draw(){
        System.out.println("Drawing Triangle.");
    }
}

class Circle implements Shape{
    public void draw(){
        System.out.println("Drawing Circle.");
    }
}

class RandomShapeFactory{
    public static Shape createRandomShape(){
        Shape randomShape;

        Random random = new Random();
        int randomNo = random.nextInt() % 3 + 1;
        if (randomNo == 1){
            randomShape = new Rectangle();
        }
        else if (randomNo == 2){
            randomShape = new Triangle();
        }
        else{
            randomShape = new Circle();
        }
        return randomShape;
    }
}

class Main{
    public static void main(String[] args){
        Shape[] shapes = new Shape[10];
        for (int i = 0; i < shapes.length; i++){
            shapes[i] = RandomShapeFactory.createRandomShape();
        }
        drawAllShapes(shapes);
    }

    public static void drawAllShapes(Shape[] shapes){
        for (int i = 0; i < shapes.length; i++){
            shapes[i].draw();
        }
    }
}