面向对象 · 代码界的角色扮演

第24章 家族传承

继承、多态与封装

第 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 没有真正的"私有",用约定:

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 章的浓缩精华。把它吃透,三大特性你就真的懂了。"


【皮皮小课堂】本章要点


【翻车现场】本章的坑

坑 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): 表示?

2. (★★) 子类里写了一个和父类同名的方法,会发生什么?

3. (★★) isinstance(d, Animal) 中,如果 d 是 Dog 的实例而 Dog 继承 Animal,结果是?

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())

5. (★★ 多选) 关于面向对象的三个特性,下列说法正确的是?

二、判断题

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

🐍"皮皮注:继承、多态、封装,三件套学完,你已经能设计'一个家族'的程序了。下一章更刺激——给类加上'魔法'!让对象支持打印美化、相加、比较……"


📖 下一章,活起来的咒语:魔法方法。

📦 本章配套代码

运行方式:命令行进入目录后执行 py 文件名.py(Windows)或 python3 文件名.py(Mac/Linux)