一篇文章带你搞懂Java多态的概念、优点、实现多态的方式、以及不同方式的区别

一篇文章带你搞懂Java多态的概念、优点、使用场景

基本概念

**多态（Polymorphism）是面向对象编程的一个重要特性，它指的是同一个行为具有多个不同表现形式或形态的能力。**它允许我们使用父类的引用变量来引用子类的对象，并根据实际对象的类型调用相应的方法。多态就是同一个接口，使用不同的实例而执行不同操作，

如图所示：

多态性是对象多种表现形式的体现。

现实中，比如我们按下 F1 键这个动作：

如果当前在 Flash 界面下弹出的就是 AS 3 的帮助文档；
如果当前在 Word 下弹出的就是 Word 帮助；
在 Windows 下弹出的就是 Windows 帮助和支持。

同一个事件发生在不同的对象上会产生不同的结果。

上篇文章我们提到了方法的重写和重载

重写体现的是父类和子类的多态（也就是动态多态也称运行时多态）
重载体现的是一个类的多态(也就是静态多态也称编译时多态)

多态存在的三个必要条件

继承
重写
父类引用指向子类对象：Animal b = new Dog();

如下图：

class Shape {
    void draw() {} // 父类 Shape 中的绘制方法
}

class Circle extends Shape {
    void draw() { // 子类 Circle 中重写的绘制方法
        System.out.println("Circle.draw()");
    }
}

class Square extends Shape {
    void draw() { // 子类 Square 中重写的绘制方法
        System.out.println("Square.draw()");
    }
}

class Triangle extends Shape {
    void draw() { // 子类 Triangle 中重写的绘制方法
        System.out.println("Triangle.draw()");
    }
}

基类 Shape 定义了一个名为 draw 的方法，这个方法在子类中可以被重写。子类 Circle、Square 和 Triangle 分别继承自 Shape 类，并且在每个子类中都重写了 draw 方法以实现特定的绘制行为。

当使用多态方式调用方法时，首先检查父类中是否有该方法，如果没有，则编译错误；如果有，再去调用子类的同名方法。

多态的好处：可以使程序有良好的扩展，并可以对所有类的对象进行通用处理。

以下是一个多态实例的演示，详细说明请看注释：

public class Test {
    public static void main(String[] args) {
      show(new Cat());  // 以 Cat 对象调用 show 方法
      show(new Dog());  // 以 Dog 对象调用 show 方法
                
      Animal a = new Cat();  // 向上转型  
      a.eat();               // 调用的是 Cat 的 eat，会动态绑定到Cat类的eat()
      Cat c = (Cat)a;        // 向下转型  
      c.work();        // 调用的是 Cat 的 work
  }  
            
    public static void show(Animal a)  {
      a.eat();  
        // 类型判断，在进行向下转型之前，最好使用 instanceof 运算符进行判断，以避免类型转换异常的发生。
        if (a instanceof Cat)  {  // 猫做的事情 
            Cat c = (Cat)a;  // 向下转型
            c.work();  
        } else if (a instanceof Dog) { // 狗做的事情 
            Dog c = (Dog)a;  // 向下转型
            c.work();  
        }  
    }  
}
 
abstract class Animal {  
    abstract void eat();  
}  
  
class Cat extends Animal {  
    public void eat() {  
        System.out.println("吃鱼");  
    }  
    public void work() {  
        System.out.println("抓老鼠");  
    }  
}  
  
class Dog extends Animal {  
    public void eat() {  
        System.out.println("吃骨头");  
    }  
    public void work() {  
        System.out.println("看家");  
    }  
}

执行以上程序，输出结果为：

吃鱼
抓老鼠
吃骨头
看家
吃鱼
抓老鼠

虚函数

虚函数的存在是为了多态。

**Java 中其实没有虚函数的概念，**它的普通函数就相当于 C++ 的虚函数，动态绑定是Java的默认行为。如果 Java 中不希望某个函数具有虚函数特性，可以加上 final 关键字变成非虚函数。

多态的实现方式

当我们谈论多态时，通常有4种主要的方式来实现它：

1.继承和方法重写（Inheritance and Method Overriding）：

子类可以继承父类的方法，并且可以对该方法进行重写。
使用父类的引用变量来引用子类的对象，实现多态性。编译时类型为父类，运行时类型为子类。

示例：

class Animal {
    void makeSound() {
        System.out.println("动物发出声音");
    }
}

class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("狗发出汪汪声");
    }
}

class Cat extends Animal {
    @Override
    void makeSound() {
        System.out.println("猫发出喵喵声");
    }
}

public class Main {
    public static void main(String[] args) {
        Animal animal1 = new Dog();
        Animal animal2 = new Cat();

        animal1.makeSound(); // 输出 "狗发出汪汪声"
        animal2.makeSound(); // 输出 "猫发出喵喵声"
    }
}

2.接口实现（Interface Implementation）：

接口是一种将方法声明抽象化的机制，一个类可以实现一个或多个接口，并实现接口中定义的方法。
使用接口类型的引用变量来引用实现该接口的类的对象，实现多态性。编译时类型为接口，运行时类型为实现类。

示例：

interface Drawable {
    void draw();
}

class Circle implements Drawable {
    @Override
    public void draw() {
        System.out.println("绘制圆形");
    }
}

class Square implements Drawable {
    @Override
    public void draw() {
        System.out.println("绘制正方形");
    }
}

public class Main {
    public static void main(String[] args) {
        Drawable shape1 = new Circle();
        Drawable shape2 = new Square();

        shape1.draw(); // 输出 "绘制圆形"
        shape2.draw(); // 输出 "绘制正方形"
    }
}

3.方法重载（Method Overloading）：

在同一个类中定义多个同名但参数列表不同的方法。
根据传入的参数类型和数量来确定调用哪个重载方法，实现多态性。

示例：

class Calculator {
    int add(int a, int b) {
        return a + b;
    }

    double add(double a, double b) {
        return a + b;
    }
}

public class Main {
    public static void main(String[] args) {
        Calculator calculator = new Calculator();

        int result1 = calculator.add(2, 3); // 调用 int 版本的 add 方法
        double result2 = calculator.add(2.5, 3.7); // 调用 double 版本的 add 方法

        System.out.println(result1); // 输出 5
        System.out.println(result2); // 输出 6.2
    }
}

4.抽象类和抽象方法

抽象类是一种不能被实例化的类，其中可以包含抽象方法，而抽象方法是只有声明而没有具体实现的方法。
使用抽象类和抽象方法可以定义一个约束子类的模板，子类必须实现抽象类中声明的抽象方法。通过创建子类的对象，然后通过抽象类的引用来引用子类的对象，实现多态性。编译时类型为抽象类，运行时类型为子类。

示例：

abstract class Shape {
    abstract void draw();
}

class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("绘制圆形");
    }
}

class Square extends Shape {
    @Override
    void draw() {
        System.out.println("绘制正方形");
    }
}

public class Main {
    public static void main(String[] args) {
        Shape shape1 = new Circle();
        Shape shape2 = new Square();

        shape1.draw(); // 输出 "绘制圆形"
        shape2.draw(); // 输出 "绘制正方形"
    }
}

在上面的例子中，Shape 类是一个抽象类，其中定义了一个抽象方法 draw()。Circle 类和 Square 类都是 Shape 类的子类，并且必须实现 draw() 方法。通过抽象类 Shape 的引用变量分别引用 Circle 对象和 Square 对象，实现了多态性。

这四种方式都可以实现多态性，并且使代码更加灵活、可扩展，提高了可读性和可维护性。
PS：方法重载仅在同一个类中有效，不能实现跨类的多态性，而继承和方法重写、接口实现可以实现跨类的多态性。