Skip to content

第 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
False

isinstance 对父类也返回 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,子类自动跟着升级——继承「少抄代码」的好处在这里体现得很直接。

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

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

对比点PythonC++
继承写法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 的封装靠约定和自觉维持:单下划线是写给程序员看的「请勿乱碰」牌子,不是锁。想更保险,可以:

  1. 用双下划线 self.__balance:Python 会把它改名成 _BankAccount__balance,误碰的难度加大(但仍能绕过)。
  2. 只用 deposit、withdraw、get_balance 三个按钮操作,把直接碰 _balance 视为违规。

这和 C++ 的 private 形成鲜明对照——那里乱碰余额连编译都过不了。一个靠自觉,一个靠制度。