在面向对象编程（OOP）的三大支柱中，继承与多态是构建灵活、可复用代码的核心。无论是日常开发还是框架设计，这两个概念都扮演着至关重要的角色。本文将从基础概念出发，结合实例与图解，带你彻底搞懂 Java 中的继承与多态。

一、继承：站在巨人的肩膀上

1.1 什么是继承？

继承是类与类之间的 "is-a" 关系（例如 "猫是动物"），它允许子类（子类型）继承父类（超类型）的属性和方法，同时添加自身特有的功能。

核心价值：减少代码重复，实现代码复用；建立类之间的层次关系，为多态奠定基础。

1.2 继承的语法实现

在 Java 中，使用extends关键字声明继承关系：

// 父类：动物
class Animal {
    String name;
    int age;

    // 父类方法
    void eat() {
        System.out.println(name + "在吃东西");
    }
}

// 子类：猫（继承自动物）
class Cat extends Animal {
    // 子类特有方法
    void catchMouse() {
        System.out.println(name + "在抓老鼠");
    }
}

子类Cat会自动拥有父类Animal的name、age属性和eat()方法，无需重复定义。

1.3 继承的核心特性

（1）单继承限制

Java 中一个类只能直接继承一个父类（单继承），但支持多层继承（例如Cat extends Animal，PersianCat extends Cat）。

（2）成员访问权限

• public：子类可直接访问；
• protected：子类可访问（即使不在同一包）；
• 默认（包权限）：仅同包子类可访问；
• private：子类不可继承（需通过父类的public/protected方法间接访问）。

（3）super关键字

用于访问父类的成员或构造器：

• super.属性/方法：调用父类的属性或方法；
• super()：调用父类的构造器（必须放在子类构造器的第一行）。

class Cat extends Animal {
    Cat(String name, int age) {
        super(name, age); // 调用父类的构造器
    }
}

1.4 方法重写（Override）

子类可以重写父类的方法，实现 "继承基础上的定制化"。重写需满足：

• 方法名、参数列表完全相同；
• 返回值类型：父类返回类型为T，子类可返回T或T的子类（协变返回）；
• 访问权限：子类权限不能低于父类（例如父类protected，子类可public但不能默认）；
• 异常：子类抛出的异常不能多于 / 宽于父类。

用@Override注解显式声明重写，IDE 会帮我们检查语法正确性：

class Cat extends Animal {
    @Override
    void eat() { // 重写父类的eat方法
        System.out.println(name + "在吃猫粮");
    }
}

继承关系示意图

下图展示了 "动物 - 猫 - 波斯猫" 的三层继承关系，箭头表示 "extends"：

二、多态：同一行为的不同表现

2.1 什么是多态？

多态（Polymorphism）指 "同一操作作用于不同对象，产生不同结果"。例如 "动物叫" 这个行为，猫会 "喵喵"，狗会 "汪汪"。

核心价值：消除类型之间的耦合，提高代码扩展性（新增子类时无需修改调用方代码）。

2.2 多态的两种形式

（1）编译时多态（重载，Overload）

同一类中，方法名相同但参数列表不同（参数类型、个数、顺序），与返回值无关。例如：

class Calculator {
    int add(int a, int b) { return a + b; }
    double add(double a, double b) { return a + b; } // 重载
}

（2）运行时多态（重写，Override）

父类引用指向子类对象时，调用重写方法会执行子类的实现（动态绑定）。这是多态的核心。

2.3 运行时多态的实现条件

1. 继承关系：子类继承父类；
2. 方法重写：子类重写父类的方法；
3. 向上转型：父类引用指向子类对象（Parent p = new Child();）。

2.4 多态的实例演示

延续动物的例子：

public class Test {
    public static void main(String[] args) {
        Animal animal1 = new Cat("汤姆", 3); // 向上转型：Cat -> Animal
        Animal animal2 = new Dog("旺财", 2); // 向上转型：Dog -> Animal
        
        animal1.eat(); // 输出：汤姆在吃猫粮（执行Cat的eat）
        animal2.eat(); // 输出：旺财在吃狗粮（执行Dog的eat）
    }
}

class Dog extends Animal {
    @Override
    void eat() {
        System.out.println(name + "在吃狗粮");
    }
    
    void guardHouse() {
        System.out.println(name + "在看家");
    }
}

虽然animal1和animal2都是Animal类型，但调用eat()时会根据实际对象类型（Cat/Dog）执行对应方法 —— 这就是动态绑定的魔力。

2.5 转型操作

（1）向上转型（自动完成）

Parent p = new Child();

• 安全，但只能调用父类声明的方法（即使子类有特有方法也无法直接调用）。

（2）向下转型（需显式强制转换）

Child c = (Child) p;

• 需先判断类型（用instanceof），否则可能抛ClassCastException：
• if (animal1 instanceof Cat) { Cat cat = (Cat) animal1; cat.catchMouse(); // 调用子类特有方法 }

多态动态绑定示意图

下面图展示了 "父类引用调用方法时，动态绑定到子类实现" 的过程：

三、继承与多态的协同设计

3.1 里氏替换原则（LSP）

"子类对象必须能替换掉所有父类对象"—— 这是继承设计的核心原则。如果子类破坏了父类的行为约定（例如重写add方法返回减法结果），会导致多态调用出错。

3.2 实战场景：统一接口处理不同对象

假设我们需要一个方法批量处理所有动物：

// 无需关心具体是猫还是狗，统一用Animal接收
public static void feedAnimals(Animal[] animals) {
    for (Animal animal : animals) {
        animal.eat(); // 多态调用：自动匹配具体实现
    }
}

// 调用时：
Animal[] animals = {new Cat("汤姆", 3), new Dog("旺财", 2)};
feedAnimals(animals);

如果后续新增Bird类，只需让它继承Animal并重写eat()，feedAnimals无需任何修改 —— 这就是多态带来的扩展性。

3.3 常见误区

1. 成员变量不参与多态：调用animal1.name时，永远取父类的成员变量（编译时确定）；
2. 静态方法不参与多态：static方法属于类，调用时由引用类型决定；
3. 过度继承：滥用继承会导致类层次复杂、耦合度高（优先考虑组合而非继承）。

四、总结

• 继承：通过extends建立类的层次关系，实现代码复用，关键是方法重写；
• 多态：通过 "父类引用指向子类对象" 实现动态绑定，核心是 "同一行为不同实现"；
• 协同价值：继承为多态提供基础，多态通过统一接口简化调用，两者结合让代码更灵活、易扩展。

掌握继承与多态，是从 "能写代码" 到 "会设计代码" 的关键一步。在实际开发中，多思考 "是否符合里氏替换原则"、"是否可通过多态简化调用"，能帮我们写出更优雅的代码。

拓展思考：Java 的接口（interface）如何进一步强化多态？欢迎在评论区交流～