# Java 中的多态

> 原文： [https://beginnersbook.com/2013/03/polymorphism-in-java/](https://beginnersbook.com/2013/03/polymorphism-in-java/)

多态是 [OOP](https://beginnersbook.com/2013/04/oops-concepts/) 特征之一，它允许我们以不同的方式执行单个动作。例如，假设我们有一个`Animal`类，它有一个方法`sound()`。由于这是一个泛型类，所以我们不能给它一个实现，如：`Roar`，`Meow`，`Oink`等。我们不得不给出一个通用的消息。

```java
public class Animal{
   ...
   public void sound(){
      System.out.println("Animal is making a sound");   
   }
}
```

现在假设我们动物类的两个子类：`Horse`和`Cat`扩展（参见[继承](https://beginnersbook.com/2013/03/inheritance-in-java/)）`Animal`类。我们可以提供相同的方法实现，如下所示：

```java
public class Horse extends Animal{
...
    @Override
    public void sound(){
        System.out.println("Neigh");
    }
}
```

和

```java
public class Cat extends Animal{
...
    @Override
    public void sound(){
        System.out.println("Meow");
    }
}
```

正如您所看到的那样，尽管我们对所有子类`sound()`都有共同的操作，但是有不同的方法来执行相同的操作。这是多态的完美示例（允许我们以不同方式执行单个操作的功能）。仅调用泛型`sound()`方法没有任何意义，因为每个`Animal`都有不同的声音。因此，我们可以说该方法执行的操作基于对象的类型。

## 什么是编程中的多态？

多态是一种方法根据它所作用的对象做不同事物的能力。换句话说，多态允许您定义一个接口并具有多个实现。正如我们在上面的例子中看到的那样，我们已经定义了方法`sound()`并且在不同的 2 个子类中具有它的多个实现。
将在运行时确定将调用哪个`sound()`方法，因此我们上面给出的示例是**运行时多态示例**。

> 多态的类型和方法重载&amp;覆盖在单独的教程中。你可以在这里引用它们：
> 1\. [Java 中的方法重载](https://beginnersbook.com/2013/05/method-overloading/) - 这是编译时间（或静态多态）的一个例子
> 2\. [Java 中的方法覆盖](https://beginnersbook.com/2014/01/method-overriding-in-java-with-example/) - 这是运行时间（或动态多态）的一个例子
> 3\. [多态的类型 - 运行时和编译时间](https://beginnersbook.com/2013/04/runtime-compile-time-polymorphism/) - 这是我们的下一个教程，我们详细介绍了多态的类型。在推荐这个主题之前，我会建议你通过方法重载和覆盖。

让我们写下它的完整代码：

## 例 1：Java 中的多态

**运行时多态示例：**

Animal.java

```java
public class Animal{
   public void sound(){
      System.out.println("Animal is making a sound");   
   }
}
```

Horse.java

```java
class Horse extends Animal{
    @Override
    public void sound(){
        System.out.println("Neigh");
    }
    public static void main(String args[]){
    	Animal obj = new Horse();
    	obj.sound();
    }
}
```

输出：

```java
Neigh
```

Cat.java

```java
public class Cat extends Animal{
    @Override
    public void sound(){
        System.out.println("Meow");
    }
    public static void main(String args[]){
    	Animal obj = new Cat();
    	obj.sound();
    }
}
```

输出：

```java
Meow
```

## 例 2：编译时多态

方法重载另一方面是编译时多态示例。

```java
class Overload
{
    void demo (int a)
    {
       System.out.println ("a: " + a);
    }
    void demo (int a, int b)
    {
       System.out.println ("a and b: " + a + "," + b);
    }
    double demo(double a) {
       System.out.println("double a: " + a);
       return a*a;
    }
}
class MethodOverloading
{
    public static void main (String args [])
    {
        Overload Obj = new Overload();
        double result;
        Obj .demo(10);
        Obj .demo(10, 20);
        result = Obj .demo(5.5);
        System.out.println("O/P : " + result);
    }
}
```

这里方法`demo()`重载 3 次：第一种方法有 1 个`int`参数，第二种方法有 2 个`int`参数，第三种方法有`double`参数。要调用哪个方法取决于调用方法时传递的参数。这发生在编译时而不是运行时，因此这种类型的多态称为编译时多态。

**输出：**

```java
a: 10
a and b: 10,20
double a: 5.5
O/P : 30.25
```