多态性使您能够创建一个模块调用另一个模块，并且在编译时依赖于控制流而不是控制流。

通过使用多态性，高级模块不依赖于低级模块。两者都依赖于抽象。这有助于我们应用依赖倒置原则(https://en.wikipedia.org/wiki/Dependency_inversion_principle)。

这就是我找到上面定义的地方。在视频中大约50分钟，教练解释了上述内容。 https://www.youtube.com/watch?v=TMuno5RZNeE

多态性是程序员编写同名方法的能力，这些方法根据对象的需要，为不同类型的对象做不同的事情。例如，如果您正在开发一个名为Fraction的类和一个名为ComplexNumber的类，这两个类都可能包含一个名为display()的方法，但它们各自实现该方法的方式不同。例如，在PHP中，你可以这样实现它:

//  Class definitions

class Fraction
{
    public $numerator;
    public $denominator;

    public function __construct($n, $d)
    {
        //  In real life, you'd do some type checking, making sure $d != 0, etc.
        $this->numerator = $n;
        $this->denominator = $d;
    }

    public function display()
    {
        echo $this->numerator . '/' . $this->denominator;
    }
}

class ComplexNumber
{
    public $real;
    public $imaginary;

    public function __construct($a, $b)
    {
        $this->real = $a;
        $this->imaginary = $b;
    }

    public function display()
    {
        echo $this->real . '+' . $this->imaginary . 'i';
    }
}


//  Main program

$fraction = new Fraction(1, 2);
$complex = new ComplexNumber(1, 2);

echo 'This is a fraction: '
$fraction->display();
echo "\n";

echo 'This is a complex number: '
$complex->display();
echo "\n";

输出:

This is a fraction: 1/2
This is a complex number: 1 + 2i

其他一些答案似乎暗示多态性只与继承一起使用;例如，可能Fraction和ComplexNumber都实现了一个名为Number的抽象类，该类有一个方法display()， Fraction和ComplexNumber都必须实现这个方法。但是您不需要继承来利用多态性。

至少在动态类型语言如PHP(我不知道c++或Java)中，多态性允许开发人员调用方法，而不必事先知道对象的类型，并相信将调用方法的正确实现。例如，假设用户选择创建的数字类型:

$userNumberChoice = $_GET['userNumberChoice'];

switch ($userNumberChoice) {
    case 'fraction':
        $userNumber = new Fraction(1, 2);
        break;
    case 'complex':
        $userNumber = new ComplexNumber(1, 2);
        break;
}

echo "The user's number is: ";
$userNumber->display();
echo "\n";

在这种情况下，将调用适当的display()方法，尽管开发人员无法提前知道用户将选择分数还是复数。

多态性允许相同的例程(函数、方法)作用于不同的类型。

由于许多现有的答案将子类型与多态性混为一谈，这里有三种实现多态性的方法(包括子类型)。

参数化(泛型)多态性允许一个例程接受一个或多个类型参数，以及正常参数，并在这些类型上运行。 子类型多态性允许例程对其参数的任何子类型进行操作。 临时多态性通常使用例程重载来授予多态行为，但也可以参考其他多态性实现。

参见:

http://wiki.c2.com/?CategoryPolymorphism

https://en.wikipedia.org/wiki/Polymorphism_ (computer_science)

通常这指的是A类型对象的行为与b类型对象相似的能力。在面向对象编程中，这通常是通过继承来实现的。一些维基百科的链接来阅读更多:

面向对象编程中的多态性 类型多态性

编辑:固定破碎的链接。

OOP中的多态性意味着一个类可以有不同的类型，继承是实现多态性的一种方式。

for example, Shape is an interface, it has Square, Circle, Diamond subtypes. now you have a Square object, you can upcasting Square to Shape automatically, because Square is a Shape. But when you try to downcasting Shape to Square, you must do explicit type casting, because you can't say Shape is Square, it could be Circle as well. so you need manually cast it with code like Square s = (Square)shape, what if the shape is Circle, you will get java.lang.ClassCastException, because Circle is not Square.

在编码术语中，多态性是指您的对象可以通过继承等方式以多种类型存在。如果你创建了一个名为“Shape”的类，它定义了对象的边数，那么你可以创建一个继承它的新类，如“Square”。当你随后创建一个“Square”实例时，你可以根据需要将它从“Shape”前后转换为“Square”。