Java 多态（Polymorphism）

多态（Polymorphism）是面向对象编程中的一个重要概念，Java 也广泛支持多态。多态是指同一个方法或操作可以有不同的表现形式，或者同一对象在不同情境下可以表现出不同的行为。简单来说，多态使得不同类的对象可以通过统一的接口调用，但每个对象会有不同的行为。

在 Java 中，多态可以分为 编译时多态（静态多态）和 运行时多态（动态多态）。

---

一、编译时多态（静态多态）

编译时多态通过 方法重载（Overloading）来实现。方法重载指的是在同一个类中，方法名相同，但参数列表不同（可以是参数的数量、类型或顺序的不同）。

1. 方法重载的特点：

• 方法名相同，但参数列表不同。
• 重载的选择由编译器在编译时决定。
• 不能仅凭返回类型来进行方法重载。

示例：

class Calculator {
    // 加法方法：两个整数相加
    public int add(int a, int b) {
        return a + b;
    }

    // 加法方法：三个整数相加
    public int add(int a, int b, int c) {
        return a + b + c;
    }

    // 加法方法：两个浮点数相加
    public double add(double a, double b) {
        return a + b;
    }
}

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

        System.out.println(calc.add(1, 2));         // 调用两个整数相加的方法
        System.out.println(calc.add(1, 2, 3));      // 调用三个整数相加的方法
        System.out.println(calc.add(1.5, 2.5));     // 调用两个浮点数相加的方法
    }
}

输出:

3
6
4.0

解释：

• add(int a, int b) 和 add(int a, int b, int c) 之间的区别在于参数的数量，编译器会根据调用时传入的参数来决定调用哪个方法。
• add(double a, double b) 是因为参数类型不同，所以调用了浮点数版本的方法。

---

二、运行时多态（动态多态）

运行时多态是通过 方法重写（Overriding）来实现的。在继承关系中，子类可以重写父类的方法，子类对象通过父类引用来调用方法时，实际执行的是子类重写后的方法，而不是父类的方法。

1. 方法重写的特点：

• 子类重写父类的方法，方法签名（方法名、参数列表）必须一致。
• 子类可以改变父类方法的实现，而不需要改变方法的调用方式。
• 方法重写的动态绑定发生在运行时，程序会根据实际的对象类型来选择调用哪个方法。

2. 关键字 @Override：

使用 @Override 注解来标识重写方法。如果父类没有该方法或者签名不匹配，编译器会报错，帮助避免错误。

3. 运行时多态的示例：

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

class Dog extends Animal {
    @Override
    void sound() {
        System.out.println("狗叫：汪汪");
    }
}

class Cat extends Animal {
    @Override
    void sound() {
        System.out.println("猫叫：喵喵");
    }
}

public class Test {
    public static void main(String[] args) {
        Animal myAnimal = new Animal();
        Animal myDog = new Dog();  // 父类引用指向子类对象
        Animal myCat = new Cat();  // 父类引用指向子类对象

        myAnimal.sound();  // 调用父类方法
        myDog.sound();     // 调用子类 Dog 的重写方法
        myCat.sound();     // 调用子类 Cat 的重写方法
    }
}

输出:

动物发出声音
狗叫：汪汪
猫叫：喵喵

解释：

• myAnimal.sound() 调用的是 Animal 类中的 sound 方法。
• myDog.sound() 和 myCat.sound() 调用的是分别在 Dog 和 Cat 类中重写的方法。
• 虽然 myDog 和 myCat 的声明类型是 Animal，但是实际执行的是它们各自类中的 sound 方法，这就是 运行时多态。

4. 父类引用指向子类对象

通过父类引用来调用子类的方法，程序会根据实际的对象类型来调用对应的重写方法。即使声明类型是父类，实际调用的依然是子类的方法。

---

三、多态的优势

1. 提高灵活性：通过多态，程序在运行时可以根据对象的实际类型选择调用适当的方法，从而避免了硬编码，提高了代码的灵活性。
2. 简化代码：多态使得我们可以通过统一的接口来处理不同类型的对象，避免了大量的条件判断，简化了代码的逻辑。
3. 扩展性强：使用多态时，增加新类（如新增一个动物类型）时，不需要修改现有的代码，只需要添加新的子类，并重写父类的方法即可。

---

四、多态的实际应用场景

1. 事件监听：比如在 GUI 编程中，监听按钮点击事件时，可以将不同的按钮的事件处理方法通过统一的接口或父类方法来调用，不同的按钮可以有不同的事件处理逻辑。
2. 接口回调：Java 的集合框架广泛使用了多态。例如，List 接口的不同实现类（如 ArrayList、LinkedList）可以通过同一个 List 类型的引用进行操作。
3. 抽象工厂模式：通过抽象类或接口，定义产品的统一接口，不同的具体产品可以通过工厂方法实例化，从而达到使用多态的效果。

---

总结

• 编译时多态（静态多态）：通过 方法重载 实现，编译时确定方法调用。
• 运行时多态（动态多态）：通过 方法重写 实现，运行时根据实际对象类型决定调用哪个方法。
• 多态的好处：提高代码的可扩展性和灵活性，简化代码逻辑。

通过多态，我们可以使代码更加灵活、可扩展并易于维护，这也是 Java 面向对象编程的重要特性之一。更多详细的内容请关注其他相关文章！