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

假设一个人X。

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

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

一般来说，它是一种使用相同或表面上相似的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.

如果有人对这些人说CUT

外科医生 发型师 这个演员

会发生什么?

外科医生开始做一个切口。 发型师会开始给某人理发。 行动者会突然停止在当前场景之外的表演， 等待导演指导。

因此，上面的表示说明了什么是OOP中的多态性(相同的名称，不同的行为)。

如果你要去参加面试，面试官要求你在我们坐在的同一个房间里讲述/展示一个多态性的生动例子，比如说-

答案-门/窗

想知道吗?

通过门/窗-人可以进来，空气可以进来，光可以进来，雨可以进来，等等。

为了更好地理解它，以一种简单的方式，我使用了上面的例子。 如果你需要代码参考，请参考上面的答案。

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

下面是一个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()方法，尽管开发人员无法提前知道用户将选择分数还是复数。

简单类比解释

美国的总统采用多态。怎么做?他有很多顾问:

军事顾问 法律顾问 核物理学家(作为顾问) 等等。

每个人只应该对一件事负责:

总统不是镀锌层专家，也不是量子物理专家。他不知道很多事情。但他知道如何管理国家。

代码也是一样:关注点和职责应该被分离到相关的类/人。这使得维护代码更加容易，特别是当您正在进行更改时。变化是不可避免的。当事情发生变化时，您不希望破坏应用程序的其他部分。总统们应该专注于管理国家，而不是进入专业领域的细节:

为什么一个总统知道所有这些具体的事情是一个坏主意?

如果总统明确地告诉人们要做什么，那就意味着总统需要确切地知道要做什么。如果总统自己需要知道具体的事情，这意味着当你需要做出改变时，你需要在两个地方做出改变，而不仅仅是一个地方。

例如，如果EPA改变了污染法律，那么当这种情况发生时:你必须对EPA类和总统类进行更改。在两个地方而不是一个地方更改代码可能是危险的——因为它更难维护。

有没有更好的方法?

有一个更好的方法:总统不需要知道任何事情的细节——他可以从专门负责这些事情的人那里得到最好的建议。

他可以用多态的方法来治理国家。

使用多态方法的例子:

总统所做的就是让人们给他提建议——这就是他在现实生活中所做的——这就是一个好总统应该做的。他的顾问们都有不同的反应，但他们都知道总统是什么意思:Advise()。成百上千的人涌进他的办公室。他们是谁并不重要。总统所知道的是，当他要求他们“建议”时，他们知道如何相应回应:

public class MisterPresident
{
    public void RunTheCountry()
    {
        // assume the Petraeus and Condi classes etc are instantiated.
        petraeus.Advise(); // # Petraeus says send 100,000 troops to Fallujah
        condolezza.Advise(); // # she says negotiate trade deal with Iran
        healthOfficials.Advise(); // # they say we need to spend $50 billion on ObamaCare
    }
}

这种方法允许总统在不了解任何军事、医疗或国际外交的情况下管理国家:细节留给专家。总统需要知道的唯一一件事是:“Advise()”。

你不想要的:

public class MisterPresident
{
    public void RunTheCountry()
    {
        // people walk into the Presidents office and he tells them what to do
        // depending on who they are.

        // Fallujah Advice - Mr Prez tells his military exactly what to do.
        petraeus.IncreaseTroopNumbers();
        petraeus.ImproveSecurity();
        petraeus.PayContractors();

        // Condi diplomacy advice - Prez tells Condi how to negotiate

        condi.StallNegotiations();
        condi.LowBallFigure();
        condi.FireDemocraticallyElectedIraqiLeaderBecauseIDontLikeHim();

        // Health care

        healthOfficial.IncreasePremiums();
        healthOfficial.AddPreexistingConditions();
    }
}

NO! NO! NO! In the above scenario, the president is doing all the work: he knows about increasing troop numbers and pre-existing conditions. This means that if middle eastern policies change, then the president would have to change his commands, as well as the Petraeus class as well. We should only have to change the Petraeus class, because the President shouldn't have to get bogged down in that sort of detail. He doesn't need to know about the details. All he needs to know is that if he makes one order, everything will be taken care of. All the details should be left to the experts.

这使得总统可以做他最擅长的事情:制定总体政策，保持良好的形象，打高尔夫球。

它实际上是如何实现的——通过基类还是公共接口

简而言之，这实际上就是多态性。具体是怎么做到的呢?通过“实现一个公共接口”或者通过使用基类(继承)——参见上面的回答，它们更详细地说明了这一点。(为了更清楚地理解这个概念，您需要知道接口是什么，还需要了解继承是什么。否则，你可能会很挣扎。)

换句话说，Petraeus、Condi和healthoofficial都是“实现接口”的类——让我们称其为IAdvisor接口，它只包含一个方法:Advise()。但现在我们进入细节。

这是最理想的

    public class MisterPresident
    {
            // You can pass in any advisor: Condi, HealthOfficials,
            //  Petraeus etc. The president has no idea who it will 
            // be. But he does know that he can ask them to "advise" 
            // and that's all Mr Prez cares for.

        public void RunTheCountry(IAdvisor governmentOfficer)
        {             
            governmentOfficer.Advise();              
        }
    }


    public class USA
    {
        MisterPresident president;

        public USA(MisterPresident president)
        {
            this.president = president;
        }

        public void ImplementPolicy()
        {
            IAdvisor governmentOfficer = getAdvisor(); // Returns an advisor: could be condi, or petraus etc.
            president.RunTheCountry(governmentOfficer);
        }
    }

总结

你真正需要知道的是:

总统不需要知道细节——那些是留给别人的。 总统所需要知道的是问谁曾经走进家门给他建议-我们知道他们绝对知道当被要求建议时该做什么(因为他们实际上都是顾问(或IAdvisors))

我真的希望它能帮到你。如果你不明白任何张贴评论，我会再试一次。