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

StackOverflow https://stackoverflow.com/questions/1031273

题

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

有帮助吗？

解决方案

如果你认为希腊的任期，这应该成为显而易见的。

  • 聚=多方面的：多边=许多方面的，聚苯乙烯=许多苯乙烯 (a), ，多语种=多种语言，等等。
  • 变形=改变或形式：形态=研究生物的形式，睡眠=希腊神的梦想能够采取任何形式。

这么多的能力(在编程)到本相同的接口，不同的基本形式(数据类型)。

例如，在许多语言、整体和浮标是隐含的多态，因为你可以加、减、乘等，不论其事实类型是不同的。他们很少被认为对象，在通常的术语。

但是，同样，一个类似的 BigDecimal 或 Rational 或 Imaginary 还可以提供这些业务，尽管他们工作在不同的数据类型。

经典的例子是的 Shape 类和所有类可能继承(方形，圆形，十二面体的、不规则的多边形、水果等)。

与多态性，这些课程将具有不同的基本数据。一点形需要的仅有的两个负责协调(假定是在两个维空间然)。一个圆需要一个中心和半径。一个正方形或长方形的需要两个负责协调用于顶左右下角和(可能的)一个旋转。一个不规则的多边需求的一系列线。

通过使类负责其代码以及其数据，可以实现多态性。在这个例子中，每一类有其自己的 Draw() 功能和客户的代码可以做的事：

shape.Draw()

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

这是相对于旧的做事方式在其中的代码分离的数据，并且你将不得不等功能 drawSquare() 和 drawCircle().

对象的取向、多态性和继承权都是密切相关的概念和它们至关重要的要知道。已经有很多的"银弹"在我漫长的职业生涯，这基本上只是失败了但OO模式已证明是一个很好的一个。学习，了解它，爱它-你会很高兴你没有:-)

(a) 我原来写的那作为一个笑话但是它原来是正确的，因此，不得有趣。该momomer苯乙烯发生是由碳和氢气， C8H8, 和聚苯乙烯制成的团体， (C8H8)n.

也许我应该指出，珊瑚虫是很多次出现的信 p 虽然，现在我已经解释的笑话，甚至似乎并不有趣的。

有时候，你应该放弃，而你后面:-)

其他提示

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

这是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类会将该代码的执行委托给相关的子类。

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

我希望这会对你有所帮助。

来自在PHP中理解和应用多态性，谢谢Steve Guidetti。

  

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

     

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

     

多态的优点在于，使用不同类的代码不需要知道它正在使用哪个类，因为它们都以相同的方式使用。   多态性的现实世界类比是一个按钮。每个人都知道如何使用按钮：你只需对它施加压力。什么按钮＆＃8220;做什么，＆＃8221;但是，取决于它所连接的内容以及它的使用环境＆＃8212;但结果不会影响它的使用方式。如果你的老板告诉你按下按钮，你已经掌握了完成任务所需的所有信息。

     

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

如果有人说，切断这些人

  1. 外科医生
  2. 发型师
  3. 演员

会发生什么事？

  • 外科医生会开始做出的一切口。
  • 发型师将开始削减有人的头发。
  • 的演员就会突然停止作出的前景， 等待着导演的指导。

所以上述的表示表示了什么是多态性(相同的名称，不同的行为)在面向对象.

如果你想要采访和记者问你告诉/显示的一个活生生的例子为多态性在同一个房间我们坐在说-

答案的门窗

想知道如何?

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

为了更好地理解和在一个简单的方式我用上述例子..如果你需要的参考代码按照上述答复。

类比的简单解释

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

  1. 军事顾问
  2. 法律顾问
  3. 核物理学家（顾问）
  4. 医疗顾问
  5. 等等。

    6. 每个人只应对一件事负责：例如：

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

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

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

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

    例如，如果EPA更改了污染法律，那么当发生这种情况时：您必须更改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();
    }
}

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

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

    如何实际实现 - 通过基类或通用接口

    简而言之，这实际上是多态性。究竟是怎么做到的？通过“实现通用接口” 或使用基类（继承） - 请参阅上面的答案，更清楚地详细说明。 （为了更清楚地理解这个概念，你需要知道接口是什么，以及

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

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

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

多态性:

它的概念是面向对象的节目。能力不同对象的回应，在其各自的方式，以相同的消息称为多态性。

多态性的结果从事实上，每一个类生活在其自己的名字空间。该名内分配一类定义不冲突的名字分配以外的任何地方。这是真实的，两个实例中的变量对象的数据结构和目的方法：

  • 只是作为该领域的一C的结构是在一个受保护的名字空间，所以 被一个象的实例的变量。

  • 方法名称也受到保护。不同的名字C功能， 方法名称不是全球性的符号。名称的一个方法中的一个 类不能与冲突的方法名称中的其他课程；两个 非常不同的类可以实现相同的命名方法。

方法名称的一部分对象的接口。当一个消息发送请求，对象做些什么，信息姓名的方法的对象应该执行。因为不同的对象可以有方法具有相同的名称，意思的消息必须理解相对于特定对象，收到的信息。同一消息发送给两个不同的对象可以调用的两个不同的方法。

主要的利益的多态性是它简化编程接口。它允许公约以建立可重复使用课后课。而不是发明一个新的名为每一个新的功能添加到一个程序，同样的名字可以被重新使用。编程接口可以被描述为一套抽象的行为，除了这类实现它们。

实例：

例1: 这是一个简单的例子写的 蟒蛇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.java

public class Car {

    int price;
    String name;
    String color;

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

}

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

福特延伸的类型汽车继承它的所有成员(特性和方法)。

Ford.java

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

上述福特类扩展的汽车类，也实现了移动()方法。尽管移动的方法已经可以得到的福特通过继承、福特仍然具有实施方法在其自己的方式。这就是所谓的方法重写。

Honda.java

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

就像福特，本田还延伸的车辆类型和实施移动的方法在其自己的方式。

方法是压倒一切的一个重要特征，以使多态性。使用方法的复盖，子种类可以改变的方式方法的工作，都可以通过继承。

PolymorphismExample.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();

  }
}

多例子产出：

在PolymorphismExample类的主要方法，我已经创建了三个对象-汽车、Ford和本田。所有的三个对象称，由汽车的类型。

请注意一个重要的一点，在这里，一个超级类型可以参照一个子类型的对象，但副诗句是不可能的。其原因是，所有成员的超级提供的子类的使用继承并在编制时，编译器试图评估，如果参照类型，我们正在使用的方法他在试图访问。

因此，对于引用汽车、f和h在PolymorphismExample，移动的方法存在，从汽车的类型。因此，编译器通行证的编制过程中没有任何问题。

但是，当涉及到运行时执行，虚拟机会调用的方法的对象是子的类型。因此，该方法动()调从他们各自的实现。

因此，所有对象的类型汽车，但是在运行时间、执行取决于对象在其调用情况。这就是所谓多态性。

这通常指的能力为对象的类型的一个表现得像一个目的B型。在面向对象编程，这通常是实现通过继承。一些维基百科的链接，以详细阅读：

编辑：固定破碎的链接。

多态性是这样的：

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（）实例

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

  

将派生类型视为基类型。

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

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

http：//www.eioba。 COM / A / 1htn /如何，我解释的休息对我的妻子

从这部分阅读：

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

术语多态性来自：

poly = many

态射=改变的能力

在编程中，多态性是一种“技术”。让你“看”的在一个物体上作为一种以上的物体。例如：

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

底线，“寻找”在不同“角度”的同一物体上可以给你不同的“观点” （即不同的属性或方法）

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

为什么我们使用多态？对于初学者......抽象。此时应该足够的信息：）

一般来说，这是能够接口的许多不同类型的对象使用同样的或表面上类似。有各种不同的形式：

  • 功能负载过重:限定的多功能用相同的名称和不同的参数类型，例如sqrt(float),sqrt(double)and sqrt(复合物)。在大多数语言允许这时，编译器将会自动选择一个正确的类型参数通过它，因此，这是编制时的多态性。

  • 虚拟方法，在面向对象:一个类的方法可以有各种实现针对具体情况的其子;这些是所复盖的实施给予在基类。鉴的对象可以基类或任何其子类，正确执行是选择的，因此这是运行时间多态性。

  • 模板：一个特征一些面向对象的语言，从而由一个功能、类，等等。可以参数化的类型。例如，可以限定一个通用的"清单"模板类，并随后的实例，它为"整数列表","串名单"，甚至"列表中列出的串"等。一般来说，你写的代码一旦对一个数据结构的任意件类型，和编译器产生的版本，它为各单元类型。

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

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

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

这只是一个可能设计的例子（在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());
}

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

c ++中的多态性

希望它有所帮助。提取物......

  

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

Type1 x;
Type2 y;

f(x);
f(y);
  

这里， f（）是执行某些操作，并且给出值 x 和 y 作为输入。要具有多态性， f（）必须能够使用至少两种不同类型的值（例如 int 和 double ），查找和执行适合类型的代码。

（续 c ++中的多态性）

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

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

多态性是程序员根据这些对象的需要编写同名方法的能力，这些方法针对不同类型的对象执行不同的操作。例如，如果您正在开发一个名为 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 = 
多态性是程序员根据这些对象的需要编写同名方法的能力，这些方法针对不同类型的对象执行不同的操作。例如，如果您正在开发一个名为 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 创建的类型：


<*>


在这种情况下，将调用相应的 display（）方法，即使开发人员无法提前知道用户是选择分数还是复数。
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（）方法，即使开发人员无法提前知道用户是选择分数还是复数。

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

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

考虑一个人X.

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

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

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

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

多态性：

  

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

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

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

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

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

SuperClass： 

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?");
    }
}

执行方法，引用要启动的父类： 

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。 这就是多态的概念。 这里还探讨了继承的概念，其中一个类可以使用或者由子类进一步定义。

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

多允许在相同的程序(功能、方法)采取行动在不同的类型。

由于许多现有的答案都是混为一谈子类型与多态性，这三种方式(包括子类型)来执行多态性。

  • Parameteric(通用)多 允许一个例行程序来接受一个或多个类型参数，除正常参数，并运行自身在这些类型。
  • 亚型的多 允许一个程序行事的任何类型的其参数。
  • 特别多 通常使用例行程序过载于许多形态的行为，但可参照其他多态性的实现。

参见：

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

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

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

编码术语中的多态性是指您的对象可以通过继承等以多种类型存在。如果您创建一个名为“Shape”的类。它定义了对象所具有的边数，然后您可以创建一个继承它的新类，例如“Square”。当您随后创建“Square”的实例时然后你可以从“形状”向后和向前投射它。到“方形”根据需要。

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

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

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

许可以下： CC-BY-SA 和 归因
不隶属于 StackOverflow
scroll top