我知道这是一个有很多好答案的老问题，但我想用一句话来回答:

将派生类型视为其基类型。

上面有很多例子可以说明这一点，但我觉得这是一个很好的简明答案。

在面向对象语言中，多态性允许通过同一个接口处理和处理不同的数据类型。例如，考虑c++中的继承: 类B派生自类A。类型为A*的指针(指向类A的指针)可以用来处理类A的对象和类B的对象。

一般来说，它是一种使用相同或表面上相似的API来为许多不同类型的对象提供接口的能力。有多种形式:

Function overloading: defining multiple functions with the same name and different parameter types, such as sqrt(float), sqrt(double) and sqrt(complex). In most languages that allow this, the compiler will automatically select the correct one for the type of argument being passed into it, thus this is compile-time polymorphism. Virtual methods in OOP: a method of a class can have various implementations tailored to the specifics of its subclasses; each of these is said to override the implementation given in the base class. Given an object that may be of the base class or any of its subclasses, the correct implementation is selected on the fly, thus this is run-time polymorphism. Templates: a feature of some OO languages whereby a function, class, etc. can be parameterised by a type. For example, you can define a generic "list" template class, and then instantiate it as "list of integers", "list of strings", maybe even "list of lists of strings" or the like. Generally, you write the code once for a data structure of arbitrary element type, and the compiler generates versions of it for the various element types.

多态性字面上的意思是多种形状。(或多种形式): 对象来自不同的类和同名方法，但工作流不同。 一个简单的例子是:

假设一个人X。

他只是一个人，但他的行为却像许多人一样。 你可能会问:

他是他母亲的儿子。 朋友对朋友。 兄弟之于姐妹。

多态是指您可以将对象视为某个对象的通用版本，但当您访问它时，代码将确定它的确切类型并调用相关代码。

下面是一个c#的例子。在控制台应用程序中创建四个类:

public abstract class Vehicle
{
    public abstract int Wheels;
}

public class Bicycle : Vehicle
{
    public override int Wheels()
    {
        return 2;
    }
}

public class Car : Vehicle
{
    public override int Wheels()
    {
        return 4;
    }
}

public class Truck : Vehicle
{
    public override int Wheels()
    {
        return 18;
    }
}

现在在控制台应用程序模块的Main()中创建以下内容:

public void Main()
{
    List<Vehicle> vehicles = new List<Vehicle>();

    vehicles.Add(new Bicycle());
    vehicles.Add(new Car());
    vehicles.Add(new Truck());

    foreach (Vehicle v in vehicles)
    {
        Console.WriteLine(
            string.Format("A {0} has {1} wheels.",
                v.GetType().Name, v.Wheels));
    }
}

在这个例子中，我们创建了一个基类Vehicle的列表，它不知道它的每个子类有多少个轮子，但是知道每个子类负责知道它有多少个轮子。

然后我们将自行车、汽车和卡车添加到列表中。

接下来，我们可以循环遍历列表中的每个Vehicle，并将它们都视为相同的，但是当我们访问每个Vehicles 'Wheels'属性时，Vehicle类将该代码的执行委托给相关的子类。

该代码被称为多态代码，因为执行的确切代码是由在运行时引用的子类决定的。

我希望这对你有所帮助。

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

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

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