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

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

下面的代码演示了多态性:

超类:

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

child，另一个子类:

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

希望这能帮到你，让你明白。 当我找到一台我可以用来验证代码的计算机时，我会发布结果。谢谢您的耐心等待!

什么是多态性?

多态性是一种能力:

调用专门化类型实例上的操作时，只知道其泛化类型，而调用专门化类型的方法，而不调用泛化类型的方法: 这就是动态多态性。 定义几个具有保存名称但参数不同的方法: 这是静态多态。

首先是历史定义，也是最重要的。

多态用于什么?

它允许创建类层次结构的强类型一致性，并做一些神奇的事情，比如管理不同类型的对象列表，而不知道它们的类型，只知道它们的父类型之一，以及数据绑定。

强类型和弱类型

样本

这里有一些形状，如点、线、矩形和圆，它们的Draw()操作要么不接受任何参数，要么使用参数设置超时来删除它们。

public class Shape
{
 public virtual void Draw()
 {
   DoNothing();
 }
 public virtual void Draw(int timeout)
 {
   DoNothing();
 }
}

public class Point : Shape
{
 int X, Y;
 public override void Draw()
 {
   DrawThePoint();
 }
}

public class Line : Point
{
 int Xend, Yend;
 public override Draw()
 {
   DrawTheLine();
 }
}

public class Rectangle : Line
{
 public override Draw()
 {
   DrawTheRectangle();
 }
}

var shapes = new List<Shape> { new Point(0,0), new Line(0,0,10,10), new rectangle(50,50,100,100) };

foreach ( var shape in shapes )
  shape.Draw();

这里Shape类和Shape. draw()方法应该被标记为抽象。

它们不是用来理解的。

解释

如果没有多态性，使用抽象-虚拟-重写，在解析形状时，只调用Spahe.Draw()方法，因为CLR不知道要调用什么方法。它调用我们所作用的类型的方法，这里的类型是Shape，因为列表声明。所以代码什么都不做。

通过多态性，CLR能够推断我们使用所谓的虚拟表所操作的对象的真实类型。它调用good方法，如果Shape是Point调用Shape。draw ()所以代码画出了形状。

更多的阅读

c# -多态性(1级)

Java中的多态性(要求等级2)

多态性(c#编程指南)

虚方法表

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

假设一个人X。

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

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

多态性是一个对象具有多种形式的能力。在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。我希望这能有所帮助。

让我们打个比方。对于一个特定的音乐剧本，每个演奏它的音乐家都有自己的诠释。

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

如果你是音乐作品的听众，你可以参考剧本，例如巴赫的“富加与托卡塔”，每个演奏它的音乐家都以自己的方式多态地演奏。

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

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

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

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