什么是多态，它是什么，以及它是如何使用的？

Question

Answer 1

如果你考虑这个术语的希腊词根，它应该变得明显。

Poly = many：polygon = many-sided，polystyrene = many styrenes（a），polyglot = many languages，依此类推。
形态=变化或形式：形态=研究生物形态，Morpheus =希腊梦之神能够采取任何形式。

因此，多态性是（在编程中）为不同的底层形式（数据类型）呈现相同的接口的能力。

例如，在许多语言中，整数和浮点数是隐式多态的，因为您可以添加，减去，乘法等，而不管类型是否不同。它们很少被视为通常术语中的对象。

但是，同样地，像BigDecimal或Rational或Imaginary这样的类也可以提供这些操作，即使它们在不同的数据类型上运行。

经典的例子是Shape类和所有可以从它继承的类（正方形，圆形，十二面体，不规则多边形，splat等）。

使用多态，这些类中的每一个都将具有不同的底层数据。点形状只需要两个坐标（假设它当然在二维空间中）。圆圈需要一个圆心和半径。正方形或矩形需要两个坐标用于左上角和右下角以及（可能）旋转。不规则多边形需要一系列线条。

通过使类负责其代码及其数据，您可以实现多态。在这个例子中，每个类都有自己的Draw()函数，客户端代码可以简单地执行：

shape.Draw()

获得任何形状的正确行为。

这与代码与数据分离的旧方法形成对比，并且您将拥有诸如drawSquare()和drawCircle()之类的函数。

面向对象，多态和继承都是密切相关的概念，它们对于了解至关重要。在我漫长的职业生涯中，有很多“银子弹”基本上刚刚失败，但OO范例已经证明是一个很好的。学习它，理解它，喜欢它 - 你会很高兴你做到了:-)

（a）我最初把它写成一个笑话，但事实证明它是正确的，因此，并不那么有趣。 momomer苯乙烯恰好由碳和氢，C₈H₈制成，而聚苯乙烯由(C₈H₈)_n组成。

也许我应该说，息肉是p字母的多次出现，尽管现在我不得不解释这个笑话，即使这看起来也不好笑。

有时，你应该在你落后时退出:-)

Answer 2

我知道这是一个较老的问题，有很多好的答案，但我想包括一句话答案：

处理派生类型，就好像它是基类型一样。

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

Answer 3

（我正在浏览关于完全不同的东西的另一篇文章......并且多态性突然出现......现在我以为我知道多态性是什么......但显然不是以这种美妙的方式解释的......想要把它写在某处......更好还是会分享...）

http://www.eioba.com/a/1htn/how-i-explained-rest-to-my-wife

请阅读本部分：

.....多态性。这是一种令人讨厌的说法，即不同的名词可以使用相同的动词。

Answer 4

术语多态性来自：

poly =很多

态射=改变的能力

在编程中，多态是一种“技术”，它让你“看”一个对象是多种类型的东西。例如：

学生对象也是人物对象。如果您向学生“看”（即演员），您可能会要求提供学生证。你不能总是和一个人这样做，对吗？（一个人不一定是学生，因此可能没有学生证）。但是，一个人可能有一个名字。学生也这样做。

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

所以这种技术可以让你构建可以从不同角度“看”的东西。

为什么我们使用多态？对于初学者......抽象。在这一点上它应该是足够的信息:)

Answer 5

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

函数重载：定义具有相同名称和不同参数类型的多个函数，例如sqrt（float），sqrt（double）和sqrt（complex）。在大多数允许这种情况的语言中，编译器会自动为传递给它的参数类型选择正确的语言，因此这是编译时多态。
OOP中的虚方法：类的方法可以根据其子类的细节定制各种实现;据说这些中的每一个都覆盖了基类中给出的实现。给定一个可能是基类或其任何子类的对象，动态选择正确的实现，因此这是运行时多态。
模板：某些OO语言的一个特性，其中函数，类等可以通过类型进行参数化。例如，您可以定义一个通用的“列表”模板类，然后将其实例化为“整数列表”，“字符串列表”，甚至可能是“字符串列表列表”等。通常，您为任意元素类型的数据结构编写一次代码，编译器为各种元素类型生成它的版本。

Answer 6

让我们用一个类比。对于给定的音乐剧，每个演奏它的音乐家都会在演绎中给出自己的触觉。

音乐家可以用界面抽象，音乐家所属的类型可以是抽象类，它定义了一些全局解释规则，每个演奏的音乐家都可以用具体的类建模。

如果您是音乐作品的倾听者，您可以参考该剧本，例如：巴赫的“Fuga and Toccata”以及所有表演它的音乐家都以自己的方式多态化。

这只是一个可能的设计示例（在Java中）：

public interface Musician {
  public void play(Work work);
}

public interface Work {
  public String getScript();
}

public class FugaAndToccata implements Work {
  public String getScript() {
    return Bach.getFugaAndToccataScript();
  }
}

public class AnnHalloway implements Musician {
  public void play(Work work) {
    // plays in her own style, strict, disciplined
    String script = work.getScript()
  }
}

public class VictorBorga implements Musician {
  public void play(Work work) {
    // goofing while playing with superb style
    String script = work.getScript()
  }
}

public class Listener {
  public void main(String[] args) {
    Musician musician;
    if (args!=null && args.length > 0 && args[0].equals("C")) {
      musician = new AnnHalloway();
    } else {
      musician = new TerryGilliam();
    }
    musician.play(new FugaAndToccata());
}

Answer 7

我已经为另一个问题提供了多态性的高级概述：

Polymorphism in c++

希望能帮助到你。提取物......

...它有助于从简单的测试开始和[多态性]的定义。考虑一下代码：

Type1 x;
Type2 y;

f(x);
f(y);

在这里，f()将执行一些操作，并被赋予值x和y作为输入。为了具有多态性，f()必须能够使用至少两种不同类型（例如int和double）的值进行操作，找到并执行适合类型的代码。

（继续在Polymorphism in c++）

Answer 8

多态性是一种物体的能力，可以采取多种形式。例如，在人类中，当我们谈论关系时，人可以以多种形式行事。 EX：一个男人是他儿子的父亲，他是他妻子的丈夫，他是他的学生的老师。

Answer 9

多态性是一种物体采取多种形式的能力。当父类引用用于引用子类对象时，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。我希望它有所帮助。

Answer 10

多态性是程序员根据这些对象的需要编写同名方法的能力，这些方法针对不同类型的对象执行不同的操作。例如，如果您正在开发一个名为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），多态性允许开发人员在不必提前知道对象类型的情况下调用方法，并相信方法的正确实现将会叫做。例如，假设用户选择创建的Number类型：

$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()方法。

Answer 11

在面向对象的编程中，多态性是指编程语言根据数据类型或类不同地处理对象的能力。更具体地说，它是重新定义派生类的方法的能力。

Answer 12

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

这是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，并对它们进行相同的处理，但是当我们访问每个Vehicle'Wheels'属性时，Vehicle类将该代码的执行委托给相关的子类。

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

我希望这对你有所帮助。

Answer 13

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

考虑一个人X.

他只是一个人，但他的行为很多。你可能会问：

他是他母亲的儿子。朋友给他的朋友。他妹妹的兄弟。

Answer 14

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

例如，Shape是一个界面，它有Square，Circle，Diamond子类型。现在你有了一个Square对象，你可以自动将Square转换为Shape，因为Square是一个Shape。但是当你尝试向下转换Shape到Square时，你必须进行显式类型转换，因为你不能说Shape是Square，它也可以是Circle。因此你需要手动使用像Square s = (Square)shape这样的代码来施放它，如果形状是圆形，你会得到java.lang.ClassCastException，因为圆形不是方形。

Answer 15

多态性：

根据类的实例执行不同的执行，而不是引用变量的类型。

接口类型引用变量可以引用实现该接口的任何类实例。

Answer 16

多态性是在给定类中使用对象的能力，其中构成对象的所有组件都由给定类的子类继承。这意味着一旦这个对象被一个类声明，它下面的所有子类（以及它们的子类，依此类推，直到你到达最远/最低的子类）继承对象及其组件（化妆）。

请记住，每个类必须保存在单独的文件中。

以下代码举例说明了多态性：

超级类：

public class Parent {
    //Define things that all classes share
    String maidenName;
    String familyTree;

    //Give the top class a default method
    public void speak(){
         System.out.println("We are all Parents");
    }
}

父亲，一个子类：

public class Father extends Parent{
    //Can use maidenName and familyTree here
    String name="Joe";
    String called="dad";

    //Give the top class a default method
    public void speak(){
        System.out.println("I am "+name+", the father.");
    }
}

孩子，另一个子类：

public class Child extends Father {
    //Can use maidenName, familyTree, called and name here

    //Give the top class a default method
    public void speak(){
        System.out.println("Hi "+called+". What are we going to do today?");
    }
}

执行方法，引用Parent类来启动：

public class Parenting{
    public static void main(String[] args) {
        Parent parents = new Parent();
        Parent parent = new Father();
        Parent child = new Child();

        parents.speak();
        parent.speak();
        child.speak();
    }
}

请注意，每个类都需要在单独的* .java文件中声明。代码应该编译。另请注意，您可以继续使用maidenName和familyTree。这就是多态的概念。这里还探讨了继承的概念，其中一个类可以使用或者由子类进一步定义。

希望这有助于并明确表达。当我找到一台可以用来验证代码的计算机时，我会发布结果。谢谢你的耐心！

Answer 17

多态性允许相同的例程（函数，方法）作用于不同类型。

由于许多现有的答案都将子类型与多态性混为一谈，因此这里有三种方法（包括子类型）来实现多态性。

参数（遗传）多态性允许例程除了正常参数之外还接受一个或多个类型参数，并在这些类型上运行。
子类型多态性允许例程对其参数的任何子类型起作用。
Ad hoc多态通常使用例程重载来授予多态行为，但也可以引用其他多态实现。

也可以看看：

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

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

Answer 18

在面向对象语言中，多态性允许通过相同的接口处理和处理不同的数据类型。例如，考虑C ++中的继承：类B是从类A派生的。类型为A *的指针（指向类A的指针）可用于处理类A的对象和类B的对象。

Answer 19

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

Answer 20

多态性使您能够创建一个调用另一个模块的模块，并且具有针对控制流而不是控制流的编译时依赖性点。

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

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

Answer 21

来自Understanding and Applying Polymorphism in PHP，谢谢Steve Guidetti。

多态性是一个非常简单的概念。

多态性描述了面向对象编程中的模式，其中类在共享公共接口时具有不同的功能。

多态的优点在于，使用不同类的代码不需要知道它正在使用哪个类，因为它们都以相同的方式使用。多态性的现实世界类比是一个按钮。每个人都知道如何使用按钮：你只需对它施加压力。然而，按钮“做什么”取决于它所连接的内容以及使用它的上下文 - 但结果不会影响它的使用方式。如果您的老板告诉您按下按钮，您已经拥有执行任务所需的所有信息。

在编程领域，多态性用于使应用程序更加模块化和可扩展。您可以根据需要创建可互换的对象，而不是描述不同操作过程的混乱条件语句。这是多态性的基本目标。

Answer 22

如果有人对这些人说过CUT

外科医生
发型师
演员

会发生什么？

外科医生会开始做切口。
发型师会开始剪掉某人的头发。
演员将突然停止在当前场景中行动，等待导演指导。

所以上面的表示显示了OOP中的多态（同名，不同行为）是什么。

如果您要参加面试，面试官要求您告诉/展示我们所在的同一房间的多态性的实例，比如说 -

答案 - 门/窗

想知道怎么样？

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

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

Answer 23

Simple Explanation by analogy

美国总统采用多态性。怎么样？好吧，他有很多顾问：

军事顾问
法律顾问
核物理学家（顾问）
医疗顾问
等等

每个人都应该对一件事负责：例如：

总统不是锌涂层或量子物理专家。他不知道很多事情 - 但他只知道一件事：如何管理这个国家。

它与代码有点相同：关注点和责任应该与相关的类/人分开。否则你会让总统知道世界上的一切 - 整个维基百科。想象一下，将整个维基百科放在一个代码类中：维护它将是一场噩梦。

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

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

例如，如果环保署改变了污染法律，那么当发生这种情况时：你必须改变EPA班级和总统班级。在两个地方而不是一个地方更改代码可能很危险 - 因为维护起来要困难得多。

有更好的方法吗？

有一种更好的方法：总统不需要知道任何事情的具体细节 - 他可以要求那些专门负责这些事情的人提供最好的建议。

他可以使用多态方法来运行这个国家。

示例 - 使用多态方法：

总统所做的就是要求人们为他提供建议 - 而这正是他在现实生活中所做的事情 - 这就是一位优秀的总统应该做的事情。他的顾问都有不同的反应，但他们都知道总统的意思：建议（）。他有数百人涌入他的办公室。实际上他们是谁并不重要。所有总统都知道，当他要求他们“建议”时，他们知道如何做出相应的回应：

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
    }
}

这种方法允许总统在不知道军事资料，医疗保健或国际外交的情况下从字面上管理国家：详细信息留给专家。总统唯一需要知道的是：“建议（）”。

你想要什么：

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();
    }
}

没有！没有！没有！在上述情景中，总统正在做所有的工作：他知道增加部队数量和预先存在的条件。这意味着，如果中东政策发生变化，总统将不得不改变他的命令，以及彼得雷乌斯班。我们只需改变彼得雷乌斯班，因为总统不应该陷入这种细节的困境。他不需要知道细节。他需要知道的是，如果他订购了一份订单，那么一切都将得到妥善处理。所有细节都应留给专家。

这使得总统可以做他最擅长的事情：制定一般政策，看起来很好并打高尔夫：P。

How is it actually implemented - through a base class or a common interface

简而言之，这实际上是多态性。究竟是怎么做到的？通过“实现通用接口”或使用基类（继承） - 请参阅上面的答案，这些答案更清楚地详述了这一点。（为了更清楚地理解这个概念，你需要知道接口是什么，你需要了解继承是什么。没有它，你可能会很困难。）

换句话说，Petraeus，Condi和HealthOfficials都将是“实现接口”的类 - 让我们称之为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);
        }
    }

Summary

你真正需要知道的是：

总统不需要知道具体细节 - 这些细节留给其他人。
所有总统需要知道的是询问谁走进门给他建议 - 我们知道他们在被要求提供建议时绝对知道该怎么做（因为他们都是实际的，顾问（或IAdvisors :)）

我真的希望它对你有所帮助。如果你发表任何评论都不明白，我会再试一次。

Answer 24

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

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

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

Answer 25

多态性：

它是面向对象编程的概念。不同对象以自己的方式响应相同消息的能力称为多态。

多态性源于每个类都在其自己的命名空间中。在类定义中指定的名称与在其外部任何位置分配的名称不冲突。这对象的数据结构和对象方法中的实例变量都是如此：

就像C结构的字段在受保护的命名空间中一样，对象的实例变量也是如此。
方法名称也受到保护。与C函数的名称不同，方法名称不是全局符号。一个类中的方法名称不能与其他类中的方法名称冲突;两个非常不同的类可以实现具有相同名称的方法。

方法名称是对象接口的一部分。当发送消息请求对象执行某些操作时，该消息将命名该对象应执行的方法。因为不同的对象可以具有相同名称的方法，所以必须相对于接收消息的特定对象来理解消息的含义。发送到两个不同对象的相同消息可以调用两个不同的方法。

多态的主要好处是它简化了编程接口。它允许建立可以在课堂上重复使用的约定。您可以重复使用相同的名称，而不是为添加到程序中的每个新函数创建新名称。编程接口可以描述为一组抽象行为，与实现它们的类完全不同。

例子：

示例1：这是一个用Python 2.x编写的简单示例。

class Animal:
    def __init__(self, name):    # Constructor of the class
        self.name = name
    def talk(self):              # Abstract method, defined by convention only
        raise NotImplementedError("Subclass must implement abstract method")

class Cat(Animal):
    def talk(self):
        return 'Meow!'

class Dog(Animal):
    def talk(self):
        return 'Woof! Woof!'

animals = [Cat('Missy'),
           Dog('Lassie')]

for animal in animals:
    print animal.name + ': ' + animal.talk()

示例2：使用方法重载和方法覆盖概念在Java中实现多态性。

让我们考虑Car讨论多态性的例子。选择福特，本田，丰田，宝马，奔驰等品牌，一切都是汽车类型。

但每个都有自己的先进功能和更先进的技术参与其移动行为。

现在让我们创建一个基本类型的汽车

car.Java

public class Car {

    int price;
    String name;
    String color;

    public void move(){
    System.out.println("Basic Car move");
    }

}

让我们实施福特汽车的例子。

福特扩展了Car类型以继承其所有成员（属性和方法）。

Ford.Java

public class Ford extends Car{
  public void move(){
    System.out.println("Moving with V engine");
  }
}

上面的Ford类扩展了Car类，并且还实现了move（）方法。尽管福特通过继承已经可以使用移动方法，但福特仍然以自己的方式实施了该方法。这称为方法覆盖。

Honda.Java

public class Honda extends Car{
  public void move(){
    System.out.println("Move with i-VTEC engine");
  }
}

就像福特一样，本田也扩展了Car类型并以自己的方式实现了移动方法。

方法覆盖是启用多态性的重要特征。使用方法覆盖，Sub类型可以通过继承更改方法的工作方式。

polymorphism example.Java

public class PolymorphismExample {
  public static void main(String[] args) {
    Car car = new Car();
    Car f = new Ford();
    Car h = new Honda();

    car.move();
    f.move();
    h.move();

  }
}

多态性示例输出：

在Polymorphism Example类主要方法中，我创建了三个对象 - 汽车，福特和本田。所有三个对象都由Car类型引用。

请注意这里的重点是超类类型可以引用Sub类类型的对象，但反之亦然。原因是超类的所有成员都可以使用继承来使用子类，并且在编译期间，编译器会尝试评估我们使用的引用类型是否具有他试图访问的方法。

因此，对于PolymorphismExample中的引用car，f和h，移动方法存在于Car类型中。因此，编译器通过编译过程没有任何问题。

但是当涉及运行时执行时，虚拟机会调用作为子类型的对象的方法。因此，方法move（）从它们各自的实现中调用。

因此，所有对象都是Car类型，但在运行时，执行依赖于调用发生的Object。这称为多态性。

Answer 26

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

编辑：修复断开的链接。

Answer 27

多态性是这样的：

class Cup {
   int capacity
}

class TeaCup : Cup {
   string flavour
}

class CoffeeCup : Cup {
   string brand
}

Cup c = new CoffeeCup();

public int measure(Cup c) {
    return c.capacity
}

你可以通过一个杯子而不是一个特定的实例。这有助于实现一般性，因为您不必为每种杯子类型提供特定的measure（）实例

什么是多态，它是什么，以及它是如何使用的？

问题描述投票：515回答：27

27个回答

Simple Explanation by analogy

How is it actually implemented - through a base class or a common interface

Summary

最新问题

什么是多态，它是什么，以及它是如何使用的？

问题描述 投票：515回答：27

27个回答

Simple Explanation by analogy

How is it actually implemented - through a base class or a common interface

Summary

最新问题

问题描述投票：515回答：27