Skip to content

第 14 章:类与对象(下)——继承、多态、封装 ​

本章能学到什么 ​

  • 继承:is-a 关系,子类复用父类的一切
  • 多态:同名方法,不同对象各自表现
  • C++ 的 virtual 与 override
  • 封装的意义:藏起细节,只留安全接口

知识链位置:第 13 章把数据和行为打包成了类。本章讲类与类之间的三种关系:可以「传下来」(继承)、可以「同名不同样」(多态)、可以「藏起来」(封装)。

场景:给学校管理系统加一种人 ​

假设已经写好了一个 Person 类,有姓名和年龄,会自我介绍。现在要加 Student。学生除了姓名年龄,还有学号,自我介绍时还要报班级。

从头写一个 Student 类,把姓名、年龄的代码抄一遍?能工作,但抄来的代码要维护两份——以后 Person 的自我介绍改了格式,Student 里的那份容易忘记跟着改。

学生是一种人。这种关系在英语里叫 is-a。面向对象给 is-a 关系配了专门的语法:继承。

继承:站在父类的肩膀上 ​

cpp
#include <iostream>
#include <string>
using namespace std;

class Person {                          // 父类(基类)
public:
    string name;
    int age;

    Person(string n, int a) {
        name = n;
        age = a;
    }

    void introduce() {
        cout << "我是" << name << ",今年" << age << "岁" << endl;
    }
};

class Student : public Person {         // 子类:继承 Person
public:
    string className;                   // 子类新增的数据

    Student(string n, int a, string c) : Person(n, a) {  // 姓名年龄交给父类构造
        className = c;
    }

    void showClass() {                  // 子类新增的行为
        cout << name << "在" << className << "班" << endl;  // 父类的 name 直接用
    }
};

int main() {
    Student ming("小明", 12, "六年级2");
    ming.introduce();                   // 继承自父类的本领
    ming.showClass();                   // 子类自己的本领
    return 0;
}
text
我是小明,今年12岁
小明在六年级2班

class Student : public Person 读作「Student 是一种 Person」。继承的效果:

继承规则说明
数据传下来父类的 name、age,子类对象自动拥有
行为传下来父类的 introduce(),子类对象直接能用
子类可扩展新增 className、showClass(),不影响父类
单向传递父类不知道有哪些子类,也不拥有子类的新东西

子类的构造函数写法值得注意:Student(...) : Person(n, a) 表示「先把姓名年龄交给父类的构造函数装好,我再装自己的学号班级」。像盖楼:地基(父类部分)先打好,上面的楼层(子类新增部分)才能开工。

多态:同一个命令,各自的执行 ​

给一群宠物下同一个命令「叫一声」,狗汪汪、猫喵喵。命令相同,执行各不相同——这就是多态。

C++ 里要实现多态,父类的方法要加 virtual 关键字,意思是「这个行为允许子类重新演绎」:

cpp
#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
    string name;

    Animal(string n) {
        name = n;
    }

    virtual void speak() {              // virtual:允许子类重新演绎
        cout << name << "发出声音" << endl;
    }
};

class Dog : public Animal {
public:
    Dog(string n) : Animal(n) {}

    void speak() override {             // override:明确声明「我在重写父类方法」
        cout << name << ":汪汪!" << endl;
    }
};

class Cat : public Animal {
public:
    Cat(string n) : Animal(n) {}

    void speak() override {
        cout << name << ":喵喵!" << endl;
    }
};

int main() {
    Dog d("阿黄");
    Cat c("咪咪");
    d.speak();
    c.speak();
    return 0;
}
text
阿黄:汪汪!
咪咪:喵喵!

多态真正的威力在「统一管理不同对象」时。用父类的指针把狗和猫装进同一个数组,循环下一个命令:

cpp
int main() {
    Animal* pets[2];                    // 父类指针数组:什么动物都能装
    pets[0] = new Dog("阿黄");
    pets[1] = new Cat("咪咪");

    for (int i = 0; i < 2; i++) {
        pets[i]->speak();               // 同一行代码,各自执行各自的版本
    }

    delete pets[0];                     // new 出来的对象,用 delete 释放
    delete pets[1];
    return 0;
}
text
阿黄:汪汪!
咪咪:喵喵!

pets[i]->speak() 这行代码不知道、也不需要知道指针指的是狗还是猫。程序运行到这一行时,自动找到对象真正的类型,执行对应的版本。以后新增 Duck 类,只要继承 Animal 并重写 speak(),循环一行不改。

对比点没有多态有了多态
不同动物怎么装一种动物一个数组父类指针装在一起
让全体叫一声每种动物写一段循环一个循环搞定
新增一种动物所有相关循环都要加分支只写新类,老代码不动

封装:电视遥控器的启示 ​

第 13 章已经见过 private 把数据锁起来。本章把这件事的意义说透。

用电视机不用懂显像管或液晶屏。按遥控器的「音量+」,声音变大。内部电路怎样工作,被外壳封装起来了,留给用户的只有一排安全的按钮。

类的设计同理:

cpp
class BankAccount {
private:
    double balance;                     // 余额锁在内部,外面碰不到

public:
    BankAccount() {
        balance = 0;
    }

    void deposit(double amount) {       // 按钮:存钱
        if (amount > 0) {
            balance += amount;
        }
    }

    bool withdraw(double amount) {      // 按钮:取钱,余额不足则失败
        if (amount > 0 && amount <= balance) {
            balance -= amount;
            return true;
        }
        return false;
    }

    double getBalance() {               // 按钮:查询
        return balance;
    }
};

余额不可能被改成负数,因为外面根本碰不到 balance,只能走三个按钮,按钮里有检查。电视机不会因为用户乱按而爆炸,银行账户对象也不会因为外部代码而变成非法状态。

封装给谁带来好处具体好处
类的使用者只用记几个按钮,不用懂内部
类的作者内部实现可以随时改,只要按钮不变,使用者的代码就不用改
整个项目非法状态进不来,错误被限制在类内部,好排查

构造与析构的顺序 ​

继承体系里造一个对象,构造函数从父到子依次执行;对象销毁时,析构函数顺序相反,从子到父:

cpp
#include <iostream>
using namespace std;

class Person {
public:
    Person() { cout << "造 Person 部分" << endl; }
    ~Person() { cout << "拆 Person 部分" << endl; }
};

class Student : public Person {
public:
    Student() { cout << "造 Student 部分" << endl; }
    ~Student() { cout << "拆 Student 部分" << endl; }
};

int main() {
    Student ming;
    return 0;
}
text
造 Person 部分
造 Student 部分
拆 Student 部分
拆 Person 部分

盖楼从地基往上盖,拆楼从顶层往下拆——顺序天然相反。

重写不是重载 ​

两个词容易混:

术语含义发生在哪
重载(overload)同名函数,参数不同同一个类里,第 8 章见过
重写(override)子类重新实现父类的同名方法父类和子类之间

多态靠的是重写。加上 override 标注后,如果父类里根本没有对应的 virtual 方法(比如名字拼错了),编译器会报错提醒——这是一道免费的检查。

综合例子:学校管理系统 ​

把继承和多态合起来用。系统统一保存所有人,一句「自我介绍」各说各的:

cpp
#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    string name;
    Person(string n) { name = n; }
    virtual void introduce() {
        cout << "我是" << name << endl;
    }
    virtual ~Person() {}
};

class Student : public Person {
public:
    string className;
    Student(string n, string c) : Person(n) { className = c; }
    void introduce() override {
        cout << "我是学生" << name << ",来自" << className << "班" << endl;
    }
};

class Teacher : public Person {
public:
    string subject;
    Teacher(string n, string s) : Person(n) { subject = s; }
    void introduce() override {
        cout << "我是" << subject << "老师" << name << endl;
    }
};

int main() {
    Person* people[3];
    people[0] = new Student("小明", "六年级2");
    people[1] = new Teacher("王老师", "数学");
    people[2] = new Student("小红", "六年级2");

    for (int i = 0; i < 3; i++) {
        people[i]->introduce();      // 同一命令,各自介绍
    }

    for (int i = 0; i < 3; i++) {
        delete people[i];
    }
    return 0;
}
text
我是学生小明,来自六年级2班
我是数学老师王老师
我是学生小红,来自六年级2班

以后再加「校长」「保安」,各写一个子类就行,循环照旧。系统对「种类增加」是敞开的,对「老代码修改」是关闭的——大型程序很看重这一条。

is-a 还是 has-a:继承不是万能胶 ​

看到两个类有关系就用继承,是新手常见误区。判断标准是「是一种」还是「有一个」:

关系例子该用什么
is-a(是一种)学生是一种人,狗是一种动物继承
has-a(有一个)学生有一份成绩单,汽车有一个发动机把另一个对象当成员装进来

「有一个」的写法叫组合:

cpp
class Transcript {                 // 成绩单
public:
    int chinese;
    int math;
    Transcript(int c, int m) { chinese = c; math = m; }
};

class Student {                    // 学生「有」一份成绩单
public:
    string name;
    Transcript transcript;         // 成员是另一个类的对象
    Student(string n, int c, int m) : transcript(c, m) { name = n; }
};

学生不是「一种成绩单」,所以不该继承 Transcript。继承表达的是「是一种」,用错地方,类关系会越来越别扭。有一条经验规则:能自然说出「A 是一种 B」才用继承,否则用组合。

重写时还想保留父类的版本 ​

子类重写方法后,有时想在父类版本的基础上加内容,而不是完全推翻。子类方法里可以用 父类名::方法名() 调用父类的版本:

cpp
#include <iostream>
#include <string>
using namespace std;

class Person {
public:
    string name;
    Person(string n) { name = n; }
    virtual void introduce() {
        cout << "我是" << name << endl;
    }
};

class Student : public Person {
public:
    string className;
    Student(string n, string c) : Person(n) { className = c; }
    void introduce() override {
        Person::introduce();                          // 先执行父类的介绍
        cout << "我在" << className << "班" << endl;  // 再补充自己的信息
    }
};

int main() {
    Student ming("小明", "六年级2");
    ming.introduce();
    return 0;
}
text
我是小明
我在六年级2班

格式升级时只改父类的 introduce,子类自动跟着升级——继承「少抄代码」的好处在这里体现得很直接。

【跨语言对照】继承与多态 ​

本质问题:两种语言都要支持「学生是一种人」的复用,以及「同一命令各自执行」的多态。差别在多态需不需要特别声明。

对比点C++Python
继承写法class Dog : public Animalclass Dog(Animal):
调用父类构造函数子类构造函数后写 : Animal(n)super().__init__(n)
多态的前提父类方法必须标 virtual,否则统一调用时找不到子类版本不需要任何声明,天然多态
重写的标注override(建议写,写错父类方法名时编译器会提醒)直接写同名方法即可
统一管理的容器父类指针数组 Animal* pets[]普通列表 pets = [...],什么都能装

等价代码:动物基类,狗和猫各自叫。

C++ 版:

cpp
#include <iostream>
#include <string>
using namespace std;

class Animal {
public:
    string name;

    Animal(string n) {
        name = n;
    }

    virtual void speak() {              // virtual:允许多态
        cout << name << "发出声音" << endl;
    }
    virtual ~Animal() {}                // 父类析构也标 virtual,保证正确收尾
};

class Dog : public Animal {
public:
    Dog(string n) : Animal(n) {}

    void speak() override {
        cout << name << ":汪汪!" << endl;
    }
};

class Cat : public Animal {
public:
    Cat(string n) : Animal(n) {}

    void speak() override {
        cout << name << ":喵喵!" << endl;
    }
};

int main() {
    Animal* pets[2];                    // 统一管理:父类指针
    pets[0] = new Dog("阿黄");
    pets[1] = new Cat("咪咪");

    for (int i = 0; i < 2; i++) {
        pets[i]->speak();               // 同一命令,各自执行
    }

    delete pets[0];
    delete pets[1];
    return 0;
}

Python 版(详见 《Python 从入门到精通》第 14 章):

python
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        print(self.name + "发出声音")

class Dog(Animal):                       # 继承写在类名后的括号里
    def speak(self):                     # 同名方法直接重写,无需声明
        print(self.name + ":汪汪!")

class Cat(Animal):
    def speak(self):
        print(self.name + ":喵喵!")

pets = [Dog("阿黄"), Cat("咪咪")]        # 统一管理:普通列表
for pet in pets:
    pet.speak()                          # 同一命令,各自执行

两段程序的输出完全一致:

text
阿黄:汪汪!
咪咪:喵喵!

为什么设计不一样:C++ 的多态发生在「父类指针指向子类对象」时,编译器默认按指针的类型找方法,这样最快;要按对象的真实类型找,需要运行时的额外机制,virtual 就是程序员明确申请这个机制的开关——不为用不到的功能付代价,这是 C++ 的一贯原则。Python 的变量本来就不绑定类型,方法调用永远在运行时按对象的真实类型查找,多态不需要开关,也就没有「忘记开开关」这种错误。一个是「默认朴素,按需升级」,一个是「默认灵活,始终如此」,两种取向各有适用的场合。

动手实验 ​

实验 1:给 Animal 家族新增 Duck 类(鸭子「嘎嘎」叫),加入 pets 数组一起叫。

💡 查看答案
cpp
class Duck : public Animal {
public:
    Duck(string n) : Animal(n) {}

    void speak() override {
        cout << name << ":嘎嘎!" << endl;
    }
};

int main() {
    Animal* pets[3];
    pets[0] = new Dog("阿黄");
    pets[1] = new Cat("咪咪");
    pets[2] = new Duck("大白");

    for (int i = 0; i < 3; i++) {
        pets[i]->speak();
    }

    for (int i = 0; i < 3; i++) {
        delete pets[i];
    }
    return 0;
}
text
阿黄:汪汪!
咪咪:喵喵!
大白:嘎嘎!

原来的循环一行没改——这就是多态带来的扩展性。

实验 2:给 BankAccount 写一个 main 函数:存入 100,取 30,再取 200(应失败),最后打印余额。

💡 查看答案
cpp
int main() {
    BankAccount acc;

    acc.deposit(100);
    cout << "余额:" << acc.getBalance() << endl;

    if (acc.withdraw(30)) {
        cout << "取出 30,余额:" << acc.getBalance() << endl;
    }

    if (acc.withdraw(200)) {
        cout << "取出 200" << endl;
    } else {
        cout << "取 200 失败:余额不足" << endl;
    }

    cout << "最终余额:" << acc.getBalance() << endl;
    return 0;
}
text
余额:100
取出 30,余额:70
取 200 失败:余额不足
最终余额:70

实验 3:删掉 Animal 里 speak 前面的 virtual,重新编译运行多态那段代码,观察输出的变化,并解释原因。

💡 查看答案

输出变成:

text
阿黄发出声音
咪咪发出声音

删掉 virtual 后,pets[i]->speak() 按指针的类型(Animal*)找方法,于是全部执行了父类的版本,狗和猫各自的叫声消失了。

这正是本章对照表里的关键一行:C++ 的多态需要 virtual 显式开启,而 Python 不需要任何声明。实验亲眼验证了两国语言的这条设计差异。