深色模式
第 14 章:类与对象(下)——继承、多态、封装
本章能学到什么
- 继承:is-a 关系,子类复用父类的一切
- 多态:同名方法,不同对象各自表现
- Python 的天然多态
- 封装的意义:藏起细节,只留安全接口
知识链位置:第 13 章把数据和行为打包成了类。本章讲类与类之间的三种关系:可以「传下来」(继承)、可以「同名不同样」(多态)、可以「藏起来」(封装)。
场景:给学校管理系统加一种人
假设已经写好了一个 Person 类,有姓名和年龄,会自我介绍。现在要加 Student。学生除了姓名年龄,还有班级,自我介绍时还要报班级。
从头写一个 Student 类,把姓名、年龄的代码抄一遍?能工作,但抄来的代码要维护两份——以后 Person 的自我介绍改了格式,Student 里的那份容易忘记跟着改。
学生是一种人。这种关系在英语里叫 is-a。面向对象给 is-a 关系配了专门的语法:继承。
继承:站在父类的肩膀上
python
class Person: # 父类(基类)
def __init__(self, name, age):
self.name = name
self.age = age
def introduce(self):
print("我是" + self.name + ",今年" + str(self.age) + "岁")
class Student(Person): # 子类:继承 Person,写在括号里
def __init__(self, name, age, class_name):
super().__init__(name, age) # 姓名年龄交给父类构造
self.class_name = class_name # 子类新增的数据
def show_class(self): # 子类新增的行为
print(self.name + "在" + self.class_name + "班") # 父类的 name 直接用
ming = Student("小明", 12, "六年级2")
ming.introduce() # 继承自父类的本领
ming.show_class() # 子类自己的本领text
我是小明,今年12岁
小明在六年级2班class Student(Person) 读作「Student 是一种 Person」。继承的效果:
| 继承规则 | 说明 |
|---|---|
| 数据传下来 | 父类的 name、age,子类对象自动拥有 |
| 行为传下来 | 父类的 introduce(),子类对象直接能用 |
| 子类可扩展 | 新增 class_name、show_class(),不影响父类 |
| 单向传递 | 父类不知道有哪些子类,也不拥有子类的新东西 |
子类构造函数里的 super().__init__(name, age) 值得注意:super() 指父类,这句表示「先把姓名年龄交给父类的构造函数装好,我再装自己的班级」。像盖楼:地基(父类部分)先打好,上面的楼层(子类新增部分)才能开工。
多态:同一个命令,各自的执行
给一群宠物下同一个命令「叫一声」,狗汪汪、猫喵喵。命令相同,执行各不相同——这就是多态。
Python 里实现多态不需要任何特殊声明:子类写一个同名方法,就覆盖了父类的版本:
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 + ":喵喵!")
d = Dog("阿黄")
c = Cat("咪咪")
d.speak()
c.speak()text
阿黄:汪汪!
咪咪:喵喵!多态真正的威力在「统一管理不同对象」时。把狗和猫装进同一个列表,循环下一个命令:
python
pets = [Dog("阿黄"), Cat("咪咪")] # 不同种类的对象装进同一个列表
for pet in pets:
pet.speak() # 同一行代码,各自执行各自的版本text
阿黄:汪汪!
咪咪:喵喵!pet.speak() 这行代码不知道、也不需要知道 pet 是狗还是猫。程序运行到这一行时,自动找到对象真正的类型,执行对应的版本。以后新增 Duck 类,只要继承 Animal 并重写 speak(),循环一行不改。
| 对比点 | 没有多态 | 有了多态 |
|---|---|---|
| 不同动物怎么装 | 一种动物一个列表 | 装在一起 |
| 让全体叫一声 | 每种动物写一段循环 | 一个循环搞定 |
| 新增一种动物 | 所有相关循环都要加分支 | 只写新类,老代码不动 |
Python 的方法调用永远在运行时按对象的真实类型查找版本,所以多态是「天然」的。对照 C++ 会看到一个有趣的差异:那里要标 virtual 才有多态,详见本章末尾的对照。
封装:电视遥控器的启示
第 13 章已经见过下划线命名约定。本章把这件事的意义说透。
用电视机不用懂显像管或液晶屏。按遥控器的「音量+」,声音变大。内部电路怎样工作,被外壳封装起来了,留给用户的只有一排安全的按钮。
类的设计同理:
python
class BankAccount:
def __init__(self):
self._balance = 0 # 约定:内部数据,请勿直接碰
def deposit(self, amount): # 按钮:存钱
if amount > 0:
self._balance += amount
def withdraw(self, amount): # 按钮:取钱,余额不足则失败
if 0 < amount <= self._balance:
self._balance -= amount
return True
return False
def get_balance(self): # 按钮:查询
return self._balance按约定使用这个类,余额不可能变成负数——正规途径只有三个按钮,按钮里有检查。电视机不会因为用户乱按而爆炸,银行账户对象也不会因为正常使用而变成非法状态。
| 封装给谁带来好处 | 具体好处 |
|---|---|
| 类的使用者 | 只用记几个按钮,不用懂内部 |
| 类的作者 | 内部实现可以随时改,只要按钮不变,使用者的代码就不用改 |
| 整个项目 | 非法状态进不来,错误被限制在类内部,好排查 |
构造方法的接力
继承体系里造一个对象,__init__ 不会自动接力——子类定义了 __init__ 就会覆盖父类的版本。所以前面的 Student 例子里写了 super().__init__(name, age):姓名年龄交给父类装,班级自己装。
忘记写这行,父类的属性就不会被装进去,访问时会报 AttributeError。
多层继承与 isinstance
继承可以传好几代:Person → Student → PrimaryStudent(小学生)。后代拥有所有祖先的本领。
判断一个对象「是不是某种类型」用 isinstance:
python
class Person:
def __init__(self, name):
self.name = name
class Student(Person):
pass # pass:什么都不加,先占个位置
ming = Student("小明")
print(isinstance(ming, Student)) # True:是学生
print(isinstance(ming, Person)) # True:学生也是一种人
print(isinstance(ming, str)) # False:不是字符串text
True
True
Falseisinstance 对父类也返回 True,这正体现了 is-a 关系:学生是一种人。
Python 多态的进一步:不继承也行
Python 的多态比表面上还宽松。只要一个对象有 speak 方法,哪怕不继承 Animal,也能混进 pets 列表一起点名:
python
class Robot: # 和 Animal 毫无继承关系
def __init__(self, name):
self.name = name
def speak(self):
print(self.name + ":哔哔!")
pets = [Dog("阿黄"), Cat("咪咪"), Robot("小智")]
for pet in pets:
pet.speak()text
阿黄:汪汪!
咪咪:喵喵!
小智:哔哔!这种风格有个著名的说法:「如果它走起来像鸭子、叫起来像鸭子,那它就是鸭子。」Python 关心的是对象会不会这个本领,而不是它的出身。C++ 正相反:必须先声明继承关系,编译器才允许混装。这个对照和 virtual 的故事是同一条线索的两端。
is-a 还是 has-a:继承不是万能胶
看到两个类有关系就用继承,是新手常见误区。判断标准是「是一种」还是「有一个」:
| 关系 | 例子 | 该用什么 |
|---|---|---|
| is-a(是一种) | 学生是一种人,狗是一种动物 | 继承 |
| has-a(有一个) | 学生有一份成绩单,汽车有一个发动机 | 把另一个对象当属性装进来 |
「有一个」的写法叫组合:
python
class Transcript: # 成绩单
def __init__(self, chinese, math):
self.chinese = chinese
self.math = math
class Student: # 学生「有」一份成绩单
def __init__(self, name, chinese, math):
self.name = name
self.transcript = Transcript(chinese, math) # 属性是另一个类的对象
ming = Student("小明", 88, 92)
print(ming.name + "的数学:" + str(ming.transcript.math))text
小明的数学:92学生不是「一种成绩单」,所以不该继承 Transcript。继承表达的是「是一种」,用错地方,类关系会越来越别扭。有一条经验规则:能自然说出「A 是一种 B」才用继承,否则用组合。
重写时还想保留父类的版本
子类重写方法后,有时想在父类版本的基础上加内容,而不是完全推翻。super() 可以调用父类的版本:
python
class Person:
def __init__(self, name):
self.name = name
def introduce(self):
print("我是" + self.name)
class Student(Person):
def __init__(self, name, class_name):
super().__init__(name)
self.class_name = class_name
def introduce(self):
super().introduce() # 先执行父类的介绍
print("我在" + self.class_name + "班") # 再补充自己的信息
ming = Student("小明", "六年级2")
ming.introduce()text
我是小明
我在六年级2班格式升级时只改父类的 introduce,子类自动跟着升级——继承「少抄代码」的好处在这里体现得很直接。
【跨语言对照】继承与多态
本质问题:两种语言都要支持「学生是一种人」的复用,以及「同一命令各自执行」的多态。差别在多态需不需要特别声明。
| 对比点 | Python | C++ |
|---|---|---|
| 继承写法 | class Dog(Animal): | class Dog : public Animal |
| 调用父类构造函数 | super().__init__(n) | 子类构造函数后写 : Animal(n) |
| 多态的前提 | 不需要任何声明,天然多态 | 父类方法必须标 virtual,否则统一调用时找不到子类版本 |
| 重写的标注 | 直接写同名方法即可 | override(建议写,写错父类方法名时编译器会提醒) |
| 统一管理的容器 | 普通列表 pets = [...],什么都能装 | 父类指针数组 Animal* pets[] |
等价代码:动物基类,狗和猫各自叫。
Python 版:
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() # 同一命令,各自执行C++ 版(详见 《C++ 从入门到精通》第 14 章):
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;
}两段程序的输出完全一致:
text
阿黄:汪汪!
咪咪:喵喵!为什么设计不一样:Python 的变量本来就不绑定类型,方法调用永远在运行时按对象的真实类型查找,多态不需要开关,也就没有「忘记开开关」这种错误。C++ 的多态发生在「父类指针指向子类对象」时,编译器默认按指针的类型找方法,这样最快;要按对象的真实类型找,需要运行时的额外机制,virtual 就是程序员明确申请这个机制的开关——不为用不到的功能付代价,这是 C++ 的一贯原则。一个是「默认灵活,始终如此」,一个是「默认朴素,按需升级」,两种取向各有适用的场合。
动手实验
实验 1:给 Animal 家族新增 Duck 类(鸭子「嘎嘎」叫),加入 pets 列表一起叫。
💡 查看答案
python
class Duck(Animal):
def speak(self):
print(self.name + ":嘎嘎!")
pets = [Dog("阿黄"), Cat("咪咪"), Duck("大白")]
for pet in pets:
pet.speak()text
阿黄:汪汪!
咪咪:喵喵!
大白:嘎嘎!原来的循环一行没改——这就是多态带来的扩展性。
实验 2:给 BankAccount 写一段使用代码:存入 100,取 30,再取 200(应失败),最后打印余额。
💡 查看答案
python
acc = BankAccount()
acc.deposit(100)
print("余额:" + str(acc.get_balance()))
if acc.withdraw(30):
print("取出 30,余额:" + str(acc.get_balance()))
if acc.withdraw(200):
print("取出 200")
else:
print("取 200 失败:余额不足")
print("最终余额:" + str(acc.get_balance()))text
余额:100
取出 30,余额:70
取 200 失败:余额不足
最终余额:70实验 3:写 acc._balance = -999 直接改余额,发现 Python 并不拦着。想想:封装在 Python 里靠什么维持?怎么写才更安全?
💡 查看答案
python
acc = BankAccount()
acc._balance = -999 # 能执行!解释器不拦
print(acc.get_balance()) # 输出 -999,非法状态出现了Python 的封装靠约定和自觉维持:单下划线是写给程序员看的「请勿乱碰」牌子,不是锁。想更保险,可以:
- 用双下划线
self.__balance:Python 会把它改名成_BankAccount__balance,误碰的难度加大(但仍能绕过)。 - 只用
deposit、withdraw、get_balance三个按钮操作,把直接碰_balance视为违规。
这和 C++ 的 private 形成鲜明对照——那里乱碰余额连编译都过不了。一个靠自觉,一个靠制度。
