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

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

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

超类:

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

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

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

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

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

超类:

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

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

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

面向对象编程中的多态性 类型多态性

编辑:固定破碎的链接。

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

从理解和应用PHP多态性，感谢Steve Guidetti。

Polymorphism is a long word for a very simple concept. Polymorphism describes a pattern in object oriented programming in which classes have different functionality while sharing a common interface. The beauty of polymorphism is that the code working with the different classes does not need to know which class it is using since they’re all used the same way. A real world analogy for polymorphism is a button. Everyone knows how to use a button: you simply apply pressure to it. What a button “does,” however, depends on what it is connected to and the context in which it is used — but the result does not affect how it is used. If your boss tells you to press a button, you already have all the information needed to perform the task. In the programming world, polymorphism is used to make applications more modular and extensible. Instead of messy conditional statements describing different courses of action, you create interchangeable objects that you select based on your needs. That is the basic goal of polymorphism.

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

for example, Shape is an interface, it has Square, Circle, Diamond subtypes. now you have a Square object, you can upcasting Square to Shape automatically, because Square is a Shape. But when you try to downcasting Shape to Square, you must do explicit type casting, because you can't say Shape is Square, it could be Circle as well. so you need manually cast it with code like Square s = (Square)shape, what if the shape is Circle, you will get java.lang.ClassCastException, because Circle is not Square.