多态性是一种将对象类视为父类的能力。

例如，假设有一个类叫Animal，还有一个类叫Dog，它继承自Animal。多态性是将任何Dog对象视为Animal对象的能力，如下所示:

Dog* dog = new Dog;
Animal* animal = dog;

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

假设一个人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类将该代码的执行委托给相关的子类。

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

我希望这对你有所帮助。

多态性一词来自:

多

形态性=改变的能力

在编程中，多态性是一种“技术”，它允许您将一个对象“看作”不止一种类型的事物。例如:

学生对象也是人对象。如果你“看”这个学生，你可能会问他要学生证。你不能总是对一个人这么做，对吧?(一个人不一定是学生，因此可能没有学生证)。然而，每个人可能都有名字。学生也一样。

底线是，从不同的“角度”“看”同一个对象可以给你不同的“视角”(即不同的属性或方法)

因此，这种技术可以让你构建可以从不同角度“观察”的东西。

为什么我们使用多态性?首先……抽象。在这一点上，它应该是足够的信息:)

多态性是程序员编写同名方法的能力，这些方法根据对象的需要，为不同类型的对象做不同的事情。例如，如果您正在开发一个名为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()方法，尽管开发人员无法提前知道用户将选择分数还是复数。

多态性是一个对象具有多种形式的能力。在OOP中，多态性最常见的用法是用父类引用引用子类对象。在这个用Java编写的例子中，我们有三种类型的车辆。我们创建了三个不同的对象，并尝试运行他们的轮子方法:

public class PolymorphismExample {

    public static abstract class Vehicle
    {
        public int wheels(){
            return 0;
        }
    }

    public static class Bike extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 2;
        }
    }

    public static class Car extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 4;
        }
    }

    public static class Truck extends Vehicle
    {
        @Override
        public int wheels()
        {
            return 18;
        }
    }

    public static void main(String[] args)
    {
        Vehicle bike = new Bike();
        Vehicle car = new Car();
        Vehicle truck = new Truck();

        System.out.println("Bike has "+bike.wheels()+" wheels");
        System.out.println("Car has "+car.wheels()+" wheels");
        System.out.println("Truck has "+truck.wheels()+" wheels");
    }

}

结果是:

欲了解更多信息，请访问https://github.com/m-vahidalizadeh/java_advanced/blob/master/src/files/PolymorphismExample.java。我希望这能有所帮助。