第 24 章 家族传承:继承、多态与封装
📖 本章目标:学会"继承"让子类复用父类的代码,理解"多态"和"封装"。
学完本章,你会写出结构清晰、不重复、还能"以一变应万变"的类家族。
上一章你会"造一只狗"了。这一章,你要学会"造一个狗家族"——让猫、狗、鸟共享祖产,各展所长,还把敏感数据锁进保险柜。
【开场小剧场】会叫的家族
学生: 皮皮,我要做猫、狗、鸟三个类,每个都会"叫",代码好重复啊!
皮皮: 因为它们仨本质上都是动物啊!动物都会叫、都有名字。与其各写各的,不如先写一个"动物"父类,让猫狗鸟继承它——重复的代码写一遍,独有的才自己写。
学生: 这就是程序界的"家族继承"?祖辈的财产,子孙能继承!
皮皮: 没错!今天学面向对象三大特性的第二站:继承、多态、封装。
学生: 那要是孙子不满意祖传的做法呢?
皮皮: 可以重写(override)——继承祖产,但把祖传的配方改良成自己的版本。一会儿就教你。
24.1 继承:子类拥有父类的一切
继承(inheritance):子类自动拥有父类的属性和方法,还能再加自己的。
class Animal:
"""动物:有名字,会自我介绍"""
def __init__(self, name):
self.name = name
def introduce(self):
print(f"我是{self.name}")
class Dog(Animal): # Dog 继承 Animal
def bark(self):
print(f"{self.name}:汪汪!")
class Cat(Animal): # Cat 继承 Animal
def meow(self):
print(f"{self.name}:喵喵!")
d = Dog("旺财")
d.introduce() # 我是旺财(父类的方法,继承来的!)
d.bark() # 旺财:汪汪!(自己加的)
c = Cat("咪咪")
c.introduce() # 我是咪咪
c.meow() # 咪咪:喵喵!
逐行拆解:
- class Animal::父类(也叫基类),写通用的东西:名字、自我介绍;
- class Dog(Animal)::括号里写父类,就是继承;
- d = Dog("旺财"):Dog 没写 __init__,但它自动用父类的 __init__,把 "旺财" 存进 self.name;
- d.introduce():Dog 没写 introduce,自动用父类的,打印"我是旺财";
- d.bark():这是 Dog 自己新加的方法,Animal 没有。
关键句:class Dog(Animal): 括号里写父类,就是继承。 Dog 没写 __init__ 和 introduce,但它自动能用——这就是"继承祖产"。
换例加深:能继承几层?
class Animal:
def eat(self):
print("吃东西")
class Dog(Animal):
def bark(self):
print("汪汪")
class Puppy(Dog): # 小狗再继承狗
def roll(self):
print("打滚")
p = Puppy()
p.eat() # 吃东西(从 Animal 一路传下来)
p.bark() # 汪汪(从 Dog 传下来)
p.roll() # 打滚(自己的)
继承可以传递:Puppy → Dog → Animal,祖辈的东西一路传到底。这就是"家族传承"的字面意思。
配套代码文件:code/ch24/animals.py。
💡 术语:父类也叫基类(base class) 或 超类(super class);子类也叫派生类(derived class)。记住"父/子"就够用。
24.2 方法重写:子类可以"改"父类的方法
如果子类对父类的某个方法不满意,可以重写(override):定义同名方法,把父类的盖掉。
class Dog(Animal):
def introduce(self): # 重写父类的 introduce
print(f"我是小狗{self.name},特别活泼!")
d = Dog("旺财")
d.introduce() # 我是小狗旺财,特别活泼!(不是父类那句了)
逐行拆解:
- Dog 里定义了 introduce,和父类同名;
- 调用 d.introduce():Python 先在子类找 → 找到自己的版本 → 用子类的;
- 父类的 introduce 被"盖掉"了。
规律:子类里有同名方法,就用子类的;没有,才去找父类的。 像"点外卖":自己家里有饭就吃自己家的,没有才下馆子(找父类)。
换例加深:重写 __init__ 最常用
class Dog(Animal):
def __init__(self, name, breed):
self.name = name # 手动重复父类的初始化(不推荐,见 24.3)
self.breed = breed
这样写能跑,但 self.name = name 和父类重复了。更优雅的是用 super() 交给父类办——看下一节。
💡 查错技巧:发现某个方法"表现不对",先想想——这个类是用了自己的版本,还是父类的? 重写可能就是你困惑的根源。
24.3 super():叫爸爸来帮忙
重写时,如果还想用父类的实现再补充,用 super() 调用父类方法:
class Dog(Animal):
def __init__(self, name, breed):
super().__init__(name) # 先让父类把 name 存好
self.breed = breed # 再加自己的属性
def introduce(self):
super().introduce() # 复用父类的介绍
print(f"我是{self.breed}品种")
d = Dog("旺财", "中华田园犬")
d.introduce()
输出:
我是旺财 (父类那句)
我是中华田园犬品种 (子类补充的那句)
逐行拆解:
- super().__init__(name):调父类的 __init__,把 self.name = name 交给父类办;
- self.breed = breed:父类办完,再补自己独有的;
- super().introduce():先执行父类的"我是旺财";
- print(f"我是{self.breed}品种"):再补充自己的。
super().__init__(name) 是常见套路:子类先调父类的初始化,把共同属性处理好,再处理自己独有的。 忘了它,父类属性没初始化,后面 self.name 会报 AttributeError。
换例加深:super() 也能调父类的其他方法
class Dog(Animal):
def eat(self):
super().eat() # 父类的 eat
print("再吃点狗粮") # 补充
d = Dog("旺财")
d.eat()
# 吃东西
# 再吃点狗粮
"继承父类的实现,加上自己的部分"——super() 就是那个"叫爸爸来帮忙"的开关。
🐍"皮皮注:super 的意思就是'上面那层'。它让你既能继承(自动拥有),又能增强(调用父类再加料)。这是重写时的标准姿势,别自己把父类逻辑复制一遍——复制粘贴 = 代码腐烂的开始。"
24.4 isinstance:验证"是不是一家人"
isinstance(对象, 类) 判断一个对象是不是这个类(或其子类)的实例:
print(isinstance(d, Dog)) # True
print(isinstance(d, Animal)) # True(子是父,因为 d 继承了 Animal)
print(isinstance(d, Cat)) # False
逐行拆解:
- isinstance(d, Dog):d 确实是 Dog 造出来的 → True;
- isinstance(d, Animal):Dog 继承 Animal,所以 d 也是"Animal 家族"的 → True;
- isinstance(d, Cat):d 是狗不是猫 → False。
🐍"皮皮注:
isinstance(d, Animal)返回 True,是因为 Dog 是 Animal 的子类。'狗是一种动物'——这句话在面向对象里成立,所以判断也成立。这就是继承的'是一个(is-a)'关系。"
换例加深:isinstance 和 type 的区别
print(type(d) == Dog) # True:类型完全一样
print(type(d) == Animal) # False:类型是 Dog,不是 Animal
print(isinstance(d, Animal)) # True:但 d 属于 Animal 家族
type() == 只认"亲爹",isinstance 认"整个家族"。 判断对象属于哪个类体系,用 isinstance 更合理。
💡 is-a 关系:继承就是"是一个"的关系——狗是一种动物,猫是一种动物。反过来说"动物是狗"就不成立,这正是坑 2 的根源。
24.5 多态:同一句话,不同的表现
多态(polymorphism) 字面意思"多种形态":同一个方法名,不同的对象调用,表现不一样。
class Animal:
def speak(self):
print("...")
class Dog(Animal):
def speak(self):
print("汪汪!")
class Cat(Animal):
def speak(self):
print("喵喵!")
class Bird(Animal):
def speak(self):
print("叽叽!")
# 只要是个 Animal,就都能 speak
animals = [Dog("旺财"), Cat("咪咪"), Bird("小黄")]
for animal in animals:
animal.speak() # 汪汪! 喵喵! 叽叽!
逐行拆解:
- 每个子类都重写了 speak;
- animals 列表里装的是不同类型的对象(但都是 Animal 的子类);
- for animal in animals: animal.speak():完全一样的代码,三个对象各叫各的。
神奇在哪? 循环里我们写的一样的 animal.speak(),但每只动物叫得不一样——因为运行时 Python 会去找每个对象自己的 speak。"同一句代码,不同对象不同表现" = 多态。
好处:不用 if 判断类型,加一只新动物(比如 Horse),循环一行都不用改,直接往里塞就完事。
换例加深:多态让"加新动物"零改动
class Horse(Animal):
def speak(self):
print("嘶嘶!")
animals = [Dog("旺财"), Cat("咪咪"), Bird("小黄"), Horse("黑马")]
for animal in animals:
animal.speak()
Horse 加进来,循环一个字都不用改。 这就是多态最大的价值:"面向父类写代码,新子类随意加。"
💡 对比一下用 if 的写法:
if 类型是狗: 汪汪 elif 类型是猫: 喵喵 ...——加一种动物就要加一个分支。多态把"类型判断"消灭了,代码好扩展一百倍。
24.6 封装:数据被"门卫"守着
封装(encapsulation):把数据藏起来,只通过"门卫方法"访问——别人不能乱碰内部。
Python 没有真正的"私有",用约定:
self.name:公开,谁都能碰;self._name:单下划线开头,约定"别碰我,内部用的"(只是约定,不是强制);self.__name:双下划线开头,名字会被"改头换面"(name mangling),外部obj.__name直接报错。
class Account:
def __init__(self, holder, balance):
self.holder = holder
self._balance = balance # 约定:内部数据,别直接碰
def deposit(self, amount):
self._balance += amount
def get_balance(self):
return self._balance # 提供"查询窗口"
acc = Account("小明", 100)
acc.deposit(50)
print(acc.get_balance()) # 150 —— 走正规窗口
# print(acc._balance) # 能读到,但_提示你"别乱碰"
逐行拆解:
- self._balance = balance:存内部数据,_ 开头告诉别人"这是我的私房钱";
- deposit / get_balance:两个"门卫方法",外部只能走这里;
- acc.get_balance():正规渠道查余额。
封装的智慧:万一以后改内部实现(比如余额要加密存),只要 get_balance 对外行为不变,外面代码全都不用改。 这叫"接口稳定,内部自由"。
换例加深:三档可见性对比
class Demo:
def __init__(self):
self.public = 1 # 公开
self._protected = 2 # 约定内部
self.__private = 3 # 名字会被改写
d = Demo()
print(d.public) # 1
print(d._protected) # 2(能读,但别乱碰)
# print(d.__private) # ❌ AttributeError
配套代码文件:code/ch24/staff.py。
🐍"皮皮注:记住——Python 的'私有'是君子协定,不是铁锁。
_和__是写给读代码的人看的'请勿打扰'牌子,真正的安全靠好习惯,不靠语言强制。"
24.7 实战:员工与经理
一个经典例子,用继承避免代码重复:
class Staff:
"""普通员工"""
def __init__(self, name, salary):
self.name = name
self.salary = salary
def bonus(self, ratio=0.1):
"""年终奖 = 月薪 * 比例"""
return self.salary * ratio
class Manager(Staff):
"""经理:有下属,年终奖更高"""
def __init__(self, name, salary, team_size=0):
super().__init__(name, salary) # 父类处理姓名和月薪
self.team_size = team_size
def bonus(self, ratio=0.3):
"""重写:经理的年终奖比例更高,还按团队规模加成"""
return super().bonus(ratio) + self.team_size * 100
def report(self):
print(f"经理 {self.name} 管着 {self.team_size} 名员工")
s = Staff("小李", 5000)
m = Manager("王经理", 8000, team_size=5)
print(s.bonus()) # 500.0
print(m.bonus()) # 2400.0 + 500 = 2900.0
m.report() # 经理 王经理 管着 5 名员工
逐行拆解:
- Staff.__init__:存姓名、月薪;
- Manager.__init__:super().__init__(name, salary) 把姓名月薪交给父类,再加 self.team_size;
- Manager.bonus(ratio=0.3):重写,先 super().bonus(ratio) 用父类的算法算基础部分,再加团队加成;
- s.bonus():5000 * 0.1 = 500.0;
- m.bonus():8000 * 0.3 + 5 * 100 = 2900.0。
看到了吗? 经理"继承"了员工的姓名月薪逻辑(super().__init__),又"重写"了年终奖算法——复用父类的,改造自己的,代码量减半,逻辑还清楚。
🐍"皮皮注:这个例子里,继承(复用属性)、super(交回父类)、重写(改造算法)、封装(_ 约定)全用上了——这就是 24 章的浓缩精华。把它吃透,三大特性你就真的懂了。"
【皮皮小课堂】本章要点
- 继承:
class 子类(父类):子类自动拥有父类的属性和方法。 - 重写(override):子类定义同名方法,覆盖父类的实现。
super():在子类里调用父类的方法/初始化,典型是super().__init__(...)。isinstance(obj, Class):判断对象是不是该类(或其子类)的实例。- 多态:同一个方法名,不同对象调用表现不同;循环里统一调用,扩展无需改代码。
- 封装:用
_约定"内部数据",用方法当"门卫";接口稳定,内部随便改。 - 三个特性一句话:继承(复用祖产)、多态(同话异表)、封装(数据上锁)。
【翻车现场】本章的坑
坑 1:子类 init 忘调 super().init
class Manager(Staff):
def __init__(self, name, salary, team_size):
self.team_size = team_size # ❌ 忘了 super().__init__(name, salary)
# self.name / self.salary 都没初始化!
m = Manager("王", 8000, 5)
print(m.name) # AttributeError: 'Manager' object has no attribute 'name'
子类要"继承父类属性",必须调 super().__init__(父类需要的参数),把共同属性交回父类初始化。
坑 2:isinstance 判断反了
isinstance(d, Animal) # True:狗是动物
isinstance(d, Dog) # True
isinstance(Animal(), Dog) # False:动物不一定是狗!
"子是父,父不是子。" 子类实例既是子类的实例、也是父类的实例;但父类的实例不是子类的实例。
坑 3:重写时连父类的好东西也扔了
class Dog(Animal):
def introduce(self):
print("我就是一只狗") # 把父类完整的介绍全扔了
d = Dog("旺财")
d.introduce() # 名字都没提
重写不等于"推倒重来"。需要保留父类逻辑就 super().xxx() 复用,再加自己的,别把祖产全败光。
坑 4:以为 __name 是"真私有"
class A:
def __init__(self):
self.__x = 10
a = A()
# print(a.__x) # AttributeError,访问不到
print(a._A__x) # 但这样还是能偷看到(名字被改了而已)
__x 只是被"改名字"挡一下,不是绝对安全。Python 的私有靠自觉(约定),靠文档,不靠强制。 记住:_ 是"请别碰",__ 是"挡一下下"。
坑 5:继承关系画反
class Animal(Dog): # ❌ 让动物去继承狗,逻辑反了!
...
判断谁继承谁,想"谁是谁": 狗是一种动物 → class Dog(Animal);动物是狗吗?不是。父类要写"更一般"的那个,子类写"更具体"的那个。
坑 6:忘了父类方法里也用 self
class Animal:
def __init__(self, name):
self.name = name
class Dog(Animal):
def greet(self):
print(f"你好{self.name}") # ✅ 用 self.name 没问题
这条是提醒不是坑:子类方法里访问继承来的属性,照样写 self.name(不要写成 name 或 super().name)。继承来的属性也是"自己的",用 self. 访问。
【本章习题】
一、选择题
1. (★) class Dog(Animal): 表示?
- A. Dog 是 Animal 的一个实例
- B. Dog 继承自 Animal
- C. Animal 继承自 Dog
- D. Dog 和 Animal 是同一个类
2. (★★) 子类里写了一个和父类同名的方法,会发生什么?
- A. 报错,不能重名
- B. 子类的方法覆盖父类的方法(重写)
- C. 两个方法都会执行
- D. 父类的方法覆盖子类的
3. (★★) isinstance(d, Animal) 中,如果 d 是 Dog 的实例而 Dog 继承 Animal,结果是?
- A.
True - B.
False - C. 报错
- D. 不确定
4. (★★) 下面代码,m.bonus() 的结果是?
class Staff:
def __init__(self, name, salary):
self.name = name
self.salary = salary
def bonus(self, ratio=0.1):
return self.salary * ratio
class Manager(Staff):
def __init__(self, name, salary, team_size=0):
super().__init__(name, salary)
self.team_size = team_size
def bonus(self, ratio=0.3):
return super().bonus(ratio) + self.team_size * 100
m = Manager("王", 8000, 5)
print(m.bonus())
- A.
800.0 - B.
2900.0 - C.
2400.0 - D.
500.0
5. (★★ 多选) 关于面向对象的三个特性,下列说法正确的是?
- A. 继承可以让子类复用父类的代码,避免重复
- B. 多态让"同一句调用"在不同对象上有不同表现
- C. 封装用单下划线
_约定内部数据"别乱碰" - D. 子类的
__init__里应该用super().__init__(...)处理父类的属性
二、判断题
1. (★) 子类会自动拥有父类的方法,不需要重新定义。( )
2. (★★) super().__init__(name) 的作用是调用父类的构造方法,初始化继承来的属性。( )
3. (★★) Python 的私有属性 __xxx 是绝对访问不到的。( )
4. (★★) type(obj) == ParentClass 在 obj 是子类实例时返回 True。( )
三、代码纠错题
1. (★★) 下面的 Manager 类,创建 m = Manager("王", 8000, 5) 后,m.name 会报 AttributeError,请改正:
class Staff:
def __init__(self, name, salary):
self.name = name
self.salary = salary
class Manager(Staff):
def __init__(self, name, salary, team_size):
self.team_size = team_size
2. (★★) 下面代码,学生想让"经理"自我介绍时保留父类的介绍再加一句,但名字丢了,请改正:
class Animal:
def __init__(self, name):
self.name = name
def introduce(self):
print(f"我是{self.name}")
class Dog(Animal):
def introduce(self):
print("我是小狗,特别活泼!") # 名字没提!
四、编程实战题
1. (基础 ★) 定义一个 Shape(形状)类,有 name 属性和 area() 方法(先返回 0);再定义 Rectangle(矩形,继承 Shape),有 width 和 height,重写 area() 返回 width * height。创建矩形算面积。
2. (基础 ★★) 接上一题,再定义 Circle(圆)继承 Shape,有 radius,重写 area() 返回 3.14 * radius ** 2。然后把一个矩形和一个圆放进同一个列表,循环打印每个图形的面积(体会多态)。
3. (基础 ★★) 定义一个 Animal 基类(有 __init__(name) 和 sound() 打印"..."),子类 Dog、Cat、Duck 各重写 sound()。写一个函数 let_speak(animals) 接收列表,循环让每只动物叫;传一个三种动物的列表测试(体会多态的好处)。
4. (挑战 ★★★) 做一个 Product(商品)类:属性 name、_price(私有,用 _ 约定)、_stock(库存);方法 get_price()、set_price(new)(价格不能为负)、sell(n)(卖 n 件,库存不够就提示)、restock(n)(补货)。写一段代码测试:进货、卖出、打印余额。
【参考答案与解析】
一、选择题
1. 答案:B
class Dog(Animal): 括号里写父类 = Dog 继承 Animal。
2. 答案:B
同名方法在子类里会覆盖父类的,这叫重写(override)。
3. 答案:A
Dog 是 Animal 的子类,所以 Dog 的实例也是 Animal 的实例。
4. 答案:B
Manager.bonus 先 super().bonus(0.3) = 8000 * 0.3 = 2400,再加 team_size * 100 = 500,总共 2900.0。
5. 答案:A、B、C、D
A 对:继承复用;B 对:多态定义;C 对:_ 是约定符号;D 对:子类用 super 调父类初始化是标准做法。
二、判断题
1. 正确(√)。继承的核心好处:子类自动拥有父类的方法。
2. 正确(√)。super().__init__(...) 是子类初始化父类属性的标准做法。
3. 错误(×)。__xxx 只是名字被改写了(变 _类名__xxx),"防君子不防小人",并非绝对访问不到。
4. 错误(×)。type(obj) 返回的是实际创建 obj 的类。子类实例的 type 是子类,不是父类,所以 type(dog) == Animal 是 False。要判断"属于哪个家族",用 isinstance。
三、代码纠错题
1. 解析: Manager 的 __init__ 没初始化父类的 name、salary。改正:加上 super().__init__(name, salary):
class Manager(Staff):
def __init__(self, name, salary, team_size):
super().__init__(name, salary) # 先初始化父类属性
self.team_size = team_size
2. 解析: 重写 introduce 时把父类的介绍全扔了。改正:用 super().introduce() 复用父类,再加自己的:
class Dog(Animal):
def introduce(self):
super().introduce() # 先让父类说"我是旺财"
print("我是小狗,特别活泼!") # 再补充
d = Dog("旺财")
d.introduce()
# 我是旺财
# 我是小狗,特别活泼!
四、编程实战题
1. 参考代码:
class Shape:
def __init__(self, name):
self.name = name
def area(self):
return 0
class Rectangle(Shape):
def __init__(self, width, height):
super().__init__("矩形")
self.width = width
self.height = height
def area(self):
return self.width * self.height
r = Rectangle(4, 5)
print(r.area()) # 20
2. 参考代码:
import math
class Circle(Shape):
def __init__(self, radius):
super().__init__("圆")
self.radius = radius
def area(self):
return math.pi * self.radius ** 2
shapes = [Rectangle(4, 5), Circle(3)]
for s in shapes:
print(f"{s.name}的面积:{s.area():.2f}")
# 输出:矩形的面积:20.00 / 圆的面积:28.27 —— 同一句 s.area(),不同表现(多态)
3. 参考代码:
class Animal:
def __init__(self, name):
self.name = name
def sound(self):
print("...")
class Dog(Animal):
def sound(self):
print(f"{self.name}:汪汪!")
class Cat(Animal):
def sound(self):
print(f"{self.name}:喵喵!")
class Duck(Animal):
def sound(self):
print(f"{self.name}:嘎嘎!")
def let_speak(animals):
for a in animals:
a.sound()
let_speak([Dog("旺财"), Cat("咪咪"), Duck("小黄")])
# 旺财:汪汪! / 咪咪:喵喵! / 小黄:嘎嘎!
# 以后再加新动物,Horse,let_speak 一行都不用改
class Horse(Animal):
def sound(self):
print(f"{self.name}:嘶嘶!")
let_speak([Dog("旺财"), Horse("黑马")])
4. 参考代码:
class Product:
def __init__(self, name, price, stock):
self.name = name
self._price = price
self._stock = stock
def get_price(self):
return self._price
def set_price(self, new):
if new < 0:
print("价格不能为负!")
return
self._price = new
print(f"价格已改为 {new}")
def sell(self, n):
if n > self._stock:
print(f"库存不足!只有 {self._stock} 件")
return
self._stock -= n
print(f"卖出 {n} 件,剩余 {self._stock} 件")
def restock(self, n):
self._stock += n
print(f"补货 {n} 件,现有 {self._stock} 件")
p = Product("保温杯", 59, 10)
p.sell(3) # 卖出 3 件,剩余 7 件
p.sell(99) # 库存不足!只有 7 件
p.restock(20) # 补货 20 件,现有 27 件
p.set_price(-5) # 价格不能为负!
p.set_price(79) # 价格已改为 79
🐍"皮皮注:继承、多态、封装,三件套学完,你已经能设计'一个家族'的程序了。下一章更刺激——给类加上'魔法'!让对象支持打印美化、相加、比较……"
📖 下一章,活起来的咒语:魔法方法。