Lesson 0302 · 继承与组合

③ 面向对象程序设计 — 第 2 课

1. 重复代码从哪来

假设要写 Dog 和 Cat 两个类，写完发现它们都有 name、age、都会 eat()——重复代码出现了。

把公共部分抽出来做成「爸爸类」，两个儿子共享它。这就是继承。它和组合的关系，先记住这张表：

判断口诀只有一句：「是一种」用继承，「有一个」用组合。这一课剩下的内容，都是把这句口诀落到代码上。

2. 继承怎么写

class Animal {
protected:                  // protected：自己和子类能访问
    string name;

public:
    Animal(string n) : name(n) {}
    void eat() { cout << name << " 在吃饭" << endl; }
};

class Dog : public Animal {   // Dog 继承 Animal
public:
    Dog(string n) : Animal(n) {}   // 先初始化基类
    void bark() { cout << name << " 汪汪叫" << endl; }
};

int main() {
    Dog d("旺财");
    d.eat();     // 基类的方法，Dog 直接用
    d.bark();    // 自己的方法
    return 0;
}

3. protected —— 给子类留门

三种权限在继承里的表现，一张表看完：

如果 Animal 的 name 是 private，Dog 里 bark() 就读不到 name。所以「打算让子类用的数据」用 protected。

4. 构造与析构的顺序

Dog d("旺财");
// 执行顺序：
// 1. Animal("旺财")    ← 先构造基类
// 2. Dog 自己的部分

所以 Dog 的构造函数必须把参数传给 Animal：: Animal(n)。析构顺序相反：先析构儿子，再析构爸爸。

为什么必须这个顺序：儿子身上有一部分是从爸爸那儿继承来的，爸爸没造好，儿子没地方放；拆的时候则要先拆儿子，再拆爸爸。

5. 方法重写 —— 儿子改写法

class Cat : public Animal {
public:
    Cat(string n) : Animal(n) {}
    void eat() {   // 和基类同名，覆盖基类版本
        cout << name << " 优雅地吃饭" << endl;
    }
};

Dog 调 eat() 是「在吃饭」，Cat 调 eat() 是「优雅地吃饭」。同名覆盖，各用各的。

这里的「覆盖」是静态的：编译时看的是变量的类型。下一课会看到，想要「运行时看实际对象」，还得加 virtual。

6. 组合 —— has-a

class Engine {
public:
    void start() { cout << "引擎启动" << endl; }
};

class Car {
    Engine engine;              // 组合：Car 内部有一个 Engine
public:
    void start() { engine.start(); }   // 转交给内部的 Engine
};

看代码就能体会差别：Car 想换引擎，改一个成员类型就行；如果让 Car 继承 Engine，汽车就「是一种引擎」了，这显然说不通。

7. 完整示例 —— Person / Student

class Person {
protected:
    string name;
    int age;
public:
    Person(string n, int a) : name(n), age(a) {}
    void intro() { cout << "我是 " << name << "，" << age << " 岁" << endl; }
};

class Student : public Person {
    int score;                 // Student 自己新增的数据
public:
    Student(string n, int a, int s) : Person(n, a), score(s) {}
    void study() { cout << name << " 在学习，分数 " << score << endl; }
};

int main() {
    Student s("小明", 18, 95);
    s.intro();    // 继承来的
    s.study();    // 自己的
    return 0;
}

注意 Student 的初始化列表：: Person(n, a), score(s) —— 先父后子，和构造顺序一致。写反了也照样能编过，但读起来是在骗自己。

8. 坑点清单

• 父类数据写成 private：子类里写 name 直接编译报错。打算给子类用的数据要用 protected。
• 忘了给父类传参：构造函数里不写 : Animal(n)，而父类又没有无参构造，编译就过不去。
• 关系选错：汽车和引擎是 has-a，写成 class Car : public Engine 就成了「汽车是一种引擎」，继承来的接口全都不对味。
• 重写的参数表不一致：名字一样但参数不同，那不叫覆盖，父类版本还在，很容易调错。
• 析构顺序记反：先析构子类、再析构父类；和构造正好相反。

9. 小测

10. 动手练习

本课小结

• 继承：class 子类 : public 基类，表示 is-a 关系。
• protected：自己 + 子类可访问，类外仍然不行。
• 构造顺序：先基类后子类；初始化基类用 : Animal(n)。析构顺序相反。
• 同名方法会覆盖基类版本（这是静态覆盖，下一课的 virtual 才管运行时）。
• 组合：has-a，类里放另一个类的对象；能组合优先组合。