4.1 继承

1. 为什么需要继承：先看痛点

第三章你写过 Car 类。现在让你再写 Dog、Cat、Bird 三个类，会发现它们天天抄同一份作业：

class Dog {
    String name;
    int age;
    void eat()  { System.out.println(name + "在吃饭"); }
    void sleep(){ System.out.println(name + "在睡觉"); }
    void bark() { System.out.println(name + "汪汪叫"); }   // 独有
}

class Cat {
    String name;      // 又抄一遍
    int age;          // 又抄一遍
    void eat()  {...} // 又抄一遍
    void sleep(){...} // 又抄一遍
    void catchMouse() { ... }  // 独有
}

三个坑：

1. 抄三遍：同样的代码出现三次，文件越来越厚；
2. 改三处：需求变了（比如给 eat 加个日志），三个类挨个改，漏一处就出 bug——这正好是 3.3 说的"把变化圈在一处"的反面教材；
3. 不成体系：代码读不出来"猫和狗都是动物"这个常识。

继承就是解药：把公共部分抽成一个 Animal（父类），Dog/Cat/Bird 各自 extends 它，抄写变成"白得"。

2. extends 语法：五分钟上手

// 父类：装公共成员
class Animal {
    String name;
    int age;
    void eat()  { System.out.println(name + "在吃饭"); }
    void sleep(){ System.out.println(name + "在睡觉"); }
}

// 子类：只写自己的绝活
class Dog extends Animal {
    void bark() { System.out.println(name + "汪汪叫"); }
    // name、age、eat()、sleep() 一个字没写，全都能用！
}

// 测试
Animal a = new Animal();
a.name = "动物";
a.eat();          // 动物在吃饭

Dog d = new Dog();
d.name = "旺财";   // 白得的属性，直接用
d.eat();          // 白得的方法，直接喊 → 旺财在吃饭
d.bark();         // 自己的绝活 → 旺财汪汪叫

术语对照（教材叫法不一，都认识）：

读法：Dog extends Animal = "狗是一种动物"——is-a 关系。能不能用继承，拿这句话检验：能自然念成"X 是一种 Y"，才继承；"汽车是一种引擎"就念不通，那不是继承，是"包含"（下一章的组合）。

3. 继承了什么、没继承什么（本节考试中心）

class Animal {
    private int secret = 42;          // private 上锁
    public int getSecret() {          // 门卫
        return secret;
    }
}

class Dog extends Animal {
    void test() {
        // System.out.println(secret);      // 编译报错！锁着呢
        System.out.println(getSecret());    // 走门卫 → 42
    }
}

看到没？继承和封装不打架，反而配合默契：private 挡住子类的手，getter/setter 开受控的门。3.3 的努力在这里全部生效。

4. 三条规矩（记牢，考试常客）

规矩 1：Java 是单继承

class Dog extends Animal { }      // ✅ 一个爹
class Dog extends Animal, Robot { } // ❌ 编译报错：不能有两个直接爹

为什么？两个爹各有一个 eat()，你听谁的？——多继承的冲突问题。Java 用"单继承 + 接口"（后面章节）绕开这个坑。C++ 支持多继承，代价是著名的"钻石问题"，Java 不背这个锅。

规矩 2：可以多层继承（爷孙链）

Animal（爷爷）
  ↓ extends
Dog（爸爸）
  ↓ extends
GuideDog（导盲犬，孙子）

GuideDog 白得 Animal 和 Dog 的全部非 private 成员——属性一代代传下去。但 Java 不支持循环继承（A 继承 B、B 又继承 A，编译器直接报错）。

规矩 3：Object 是万物之祖

你写的任何类，不写 extends 时默认继承 Object。所以每个对象都有 toString()、equals() 这些方法——你没写过它们却能调用，谜底在这。继承链的最顶端永远是 Object。

5. 继承在内存里长什么样

延续全章的"栈钥匙堆实物"暗线：

Dog d = new Dog();
                ↓
栈：d（一把钥匙）
                ↓ 指向
堆：一个 Dog 对象
    ├─ 独有部分：bark() 相关
    └─ 继承部分：name、age（从 Animal 图纸上"抄"进这个对象的格子里）

注意关键点：继承不是"链接到父类"，而是 new 的时候把父类的成员直接搬进这个对象的格子里。改 d.name 只改这一只狗，Animal 类本身和别的对象毫发无伤。

6. 什么时候该用继承（动手前的判断课）

用 is-a 三问：

1. 能不能自然念出"子类是一种父类"？（狗是一种动物 ✅ / 汽车是一种引擎 ❌）
2. 子类是父类的特殊版本吗？（子类 = 父类 + 自己的绝活）
3. 这些公共成员以后都会变吗？会变 → 抽到父类只改一处（3.3 的"圈住变化"）

三个都答"是"，才动手继承。继承不是"代码放哪方便"的问题，是"世界怎么分类"的问题——这也是它叫"面向对象思想"的原因。

7. 动手练习（保姆式，在 IDEA04 项目里）

public class TestAnimal {
    public static void main(String[] args) {
        Dog d = new Dog();
        d.name = "旺财";
        d.age = 2;
        d.eat();    // 旺财在吃饭  ← 一个字没写，凭空有了
        d.sleep();  // 旺财在睡觉
        d.bark();   // 旺财汪汪叫  ← 自己的绝活
    }
}

成功标准：三行输出一字不差。特别是第一行——Dog 类里明明没有 eat()，它照样能跑，这就是"白得"的现场证据。

三个 30 秒实验（每个都值得做）：

1. private 实验：给 Animal 的 age 前加 private，回 Dog 类看 d.age = 2 报什么错——亲眼看"继承不等于随便访问"；
2. 单继承实验：再建一个 Robot 类，让 Dog 写成 extends Animal, Robot，看编译器怎么拒绝；
3. Object 实验：新建一个空类 class Empty { }，在 Test 里敲 new Empty().toString();——空类凭什么有方法？规矩 3 的现场证明。

8. 常见误区

9. 自测题（先自己答，再展开）

10. 下一步学什么

• ☑ 4.2 final关键字 ✅ 教材把 final 排在重写之前（合理：先知道"哪些不许改"）：三把锁——final 变量/方法/类，static final 常量标配，final 锁钥匙不锁车
• ☐ 复习提示：本节的 private 实验（实验 1）是理解 4.2 重写边界的前提——先做实验再往下走

相关笔记

• 3.3 封装性 ← private 门卫：本节"继承不越权"的地基
• 3.5 this关键字 ← 下一节 super 是它的镜像：this 找自己，super 找爹
• 3.8 本章小结 ← 三大特性进度条：封装 ✅ → 继承（本节） → 多态待学
• 📇 Java基础 · 索引
• 🏠 返回主页