深色模式
第 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 Animal | class 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 不需要任何声明。实验亲眼验证了两国语言的这条设计差异。
