多态

前置知识

在阅读本章前，你需要了解：Java 的类与对象基础，继承机制，以及基本的引用与对象关系。

为什么需要多态？

想象一下，你在开发一个动物园管理系统，系统中有许多不同种类的动物：猫、狗、鸟等等。每种动物都会有一个叫声方法 makeSound()，但各自的叫声显然不一样。那么，如何设计代码，让系统能够优雅地处理所有动物的叫声，而不必写一大堆 if...else 判断呢？

这就是多态帮我们解决的问题。简单来说，多态让同一段代码在面对不同类型的对象时，表现出不同的行为。它让程序更灵活、扩展性更强，也更符合面向对象“开闭原则”。

---

多态是什么？

用人话来说，多态就是“多种形态”，它允许父类引用指向子类对象，调用的方法在运行时才确认具体执行哪个版本，跟对象的实际类型相关，而非变量声明类型。

多态成立的三个条件：

1. 继承（子类继承父类或实现接口）
2. 方法重写（子类重写父类的方法）
3. 父类引用指向子类对象（向上转型）

当这三个条件都满足时，我们就得到了灵活的多态行为。

---

代码示例 1 — 最简单的多态展示

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

// 子类 Dog
class Dog extends Animal {
    @Override
    void makeSound() {
        System.out.println("汪汪");
    }
}

// 测试类
public class SimplePolymorphismDemo {
    public static void main(String[] args) {
        Animal myAnimal = new Dog(); // 向上转型：父类引用指向子类对象
        myAnimal.makeSound();        // 动态绑定：运行时调用 Dog 的 makeSound
    }
}

这段代码做了什么？

1. Animal 类声明了一个方法 makeSound，输出通用描述。
2. Dog 类继承 Animal，重写了 makeSound 方法，变成狗叫声“汪汪”。
3. 在 main 中，Animal 类型的变量 myAnimal 连接到了 Dog 对象，这就是向上转型。
4. 调用 myAnimal.makeSound() 时，虽然用的是父类变量，但实际执行的是子类重写的方法，这就是动态绑定。

---

代码示例 2 — 多态与 instanceof

有时候运行时，我们需要判断对象的实际类型，这时候 instanceof 操作符就派上用场。

class Animal {
    void makeSound() {
        System.out.println("动物叫");
    }
}

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

    void catchMouse() {
        System.out.println("抓老鼠");
    }
}

public class InstanceofDemo {
    public static void main(String[] args) {
        Animal pet = new Cat();

        pet.makeSound(); // 调用 Cat 重写的方法“喵喵”

        if (pet instanceof Cat) {
            Cat cat = (Cat) pet; // 向下转型，安全地使用 Cat 独有方法
            cat.catchMouse();
        } else {
            System.out.println("不是猫，不能抓老鼠");
        }
    }
}

这段代码做了什么？

1. pet 是 Animal 引用指向 Cat 对象。
2. 调用 makeSound()，执行的是 Cat 重写的方法“喵喵”。
3. 通过 instanceof 判断，确认 pet 是 Cat 类型。
4. 安全地进行向下转型，调用只有 Cat 独有的 catchMouse() 方法。
5. 避免了向下转型风险，提高了代码的安全性。

---

代码示例 3 — 多态的实际应用场景——图形绘制程序

假设我们在写一个图形绘制程序，所有图形都有一个绘制方法 draw()，不同的图形绘制细节不同。

import java.util.ArrayList;
import java.util.List;

// 抽象父类 Shape
abstract class Shape {
    abstract void draw();
}

// 子类 Circle 实现具体绘制
class Circle extends Shape {
    @Override
    void draw() {
        System.out.println("绘制一个圆形");
    }
}

// 子类 Rectangle 实现具体绘制
class Rectangle extends Shape {
    @Override
    void draw() {
        System.out.println("绘制一个矩形");
    }
}

// 子类 Triangle 实现具体绘制
class Triangle extends Shape {
    @Override
    void draw() {
        System.out.println("绘制一个三角形");
    }
}

public class ShapeDrawingApp {
    public static void main(String[] args) {
        List<Shape> shapes = new ArrayList<>();
        shapes.add(new Circle());
        shapes.add(new Rectangle());
        shapes.add(new Triangle());

        // 统一调用 draw 方法，展现多态性
        for (Shape shape : shapes) {
            shape.draw(); // 动态绑定：具体执行子类 draw
        }
    }
}

这段代码做了什么？

1. 定义了一个抽象类 Shape，声明抽象方法 draw()。
2. 三个具体形状类继承 Shape，分别实现了 draw() 。
3. 在主程序中，将不同形状对象放入父类类型的集合 List<Shape> 中——这就是向上转型。
4. 通过遍历 shapes，调用每个形状的 draw()，实际执行对应子类的方法，实现了运行时多态，非常灵活。

---

为什么多态这么重要？

• 扩展性好：新增一种形状，只需继承 Shape 并实现 draw()，已有代码不变。
• 代码复用与简洁：消除繁琐的类型判断，少用 if 或 switch，代码更清晰。
• 设计模式基础：很多设计模式依赖多态（策略模式、模板方法等）。

---

⚠️ 常见陷阱

向下转型的安全隐患

向上转型（父类引用指向子类对象）是安全的，但向下转型（把父类引用强制转为子类类型）却容易出现 ClassCastException 错误。

Animal animal = new Dog();
Cat cat = (Cat) animal;  // 运行时抛出 ClassCastException

避免方式：

• 始终使用 instanceof 先判断类型。
• 尽量减少向下转型，更推崇通过多态调用父类方法实现功能。

---

对比总结

特性	传统硬编码	使用多态
代码耦合度	高：需要大量 if...else 判断	低：通过方法调用与动态绑定解耦
可扩展性	差：每加新类型要改代码	好：新增子类即可，已有代码无需修改
运行时行为	静态绑定：编译阶段确定调用方法	动态绑定：运行时确定调用具体方法
代码可读性	复杂，检查和维护困难	简洁，逻辑清晰
类型安全	需要手动判断类型	多态调用避免硬编码类型判断

---

💡 实战建议

1. 多用父类引用，提高代码灵活性和扩展性。
2. 尽量把公共行为放到父类（或接口），只重写不同实现部分。
3. 谨慎使用向下转型，一定要instanceof检查，防止类型转换异常。
4. 用抽象类和接口结合多态，设计更通用的组件。
5. 多态是设计模式的基础，掌握它后更容易理解策略模式、工厂模式等。

---

小结

• 多态基于继承、方法重写与父类引用指向子类对象的组合实现。
• 通过动态绑定，程序运行时决定调用哪个子类方法。
• instanceof 用于判断对象的运行时类型，帮助安全向下转型。
• 多态让代码更简洁、易扩展，也更符合面向对象设计原则。
• 实战中避免随意向下转型，优先设计好继承体系和抽象层。

---

延伸思考

• 多态在接口和抽象类设计中有什么不同？它们各自适合什么场景？
• 动态绑定机制底层是如何实现的？虚拟机做了哪些优化？
• 如果问你重写父类的静态方法，多态是否有效？为什么？

---

欢迎你来试试修改上面示例代码，添加新的子类，或部分方法改写，感受多态带来的灵活开发。有什么难点或者困惑，也可以随时告诉我，我们一起攻克！