引言

在上一篇文章中，我们为类注入了个性和生命。现在，让我们解锁面向对象编程更强大的能力——类的继承。它让你能站在“巨人”的肩膀上，复用已有代码，高效构建新功能。想象一下：定义好通用的“车辆”蓝图，就能轻松衍生出“汽车”、“自行车”，无需重复劳动。这就是继承的魅力。

本文将带你从零掌握继承的核心：单继承、多继承、super()方法，并通过动手实践，将知识转化为你的编程技能。

一、 温故知新：上期作业参考解答

开始新旅程前，先快速回顾上期作业，巩固基础，让学习之路更平稳。

任务一：升级 Rectangle 类

目标：为 Rectangle 类添加 __str__ 方法，实现格式化输出。

classRectangle:
def__init__(self, width, height):
        self.width = width
        self.height = height

defarea(self):
return self.width * self.height

def__str__(self):
returnf"Rectangle(width={self.width}, height={self.height})"


# 测试代码
rect = Rectangle(5, 3)
print(rect)           # 输出：Rectangle(width=5, height=3)
print(f"面积: {rect.area()}")  # 输出：面积: 15

任务二：创建 Student 类

目标：构建 Student 类，管理学生信息和成绩。

classStudent:
def__init__(self, name, student_id):
        self.name = name
        self.student_id = student_id
        self.grades = []  # 存储成绩的空列表

defadd_grade(self, grade):
"""添加单科成绩"""
        self.grades.append(grade)

defaverage_grade(self):
"""计算平均分，处理无成绩情况"""
ifnot self.grades:
return0
returnsum(self.grades) / len(self.grades)

def__str__(self):
returnf"Student(name={self.name}, id={self.student_id})"


# 测试代码
stu = Student("张三", "2023001")
stu.add_grade(90)
stu.add_grade(85)
stu.add_grade(92)
print(stu)  # 输出：Student(name=张三, id=2023001)
print(f"平均成绩: {stu.average_grade():.2f}")  # 输出：平均成绩: 89.00

二、 探索新知：类的继承

继承是面向对象编程的基石。它允许子类“继承”父类的属性和方法，并添加专属功能，实现高效代码复用。

1. 什么是继承？

• 核心概念
  继承建立 “是一个” 关系。例如，“狗”是“动物”。在代码中，Dog 类可以继承 Animal 类。
• 被继承的类称为 父类 或 基类。
• 继承的类称为 子类 或 派生类。
• 核心优势
• 高效复用
  子类自动拥有父类的所有功能，告别重复代码。
• 结构清晰
  通过继承可以构建层次分明的类体系，让代码更易于理解和维护。

2. 单继承

单继承是指一个子类只继承一个父类，这是最常用的模式。

语法：class ChildClass(ParentClass):

# 父类：Animal
classAnimal:
def__init__(self, name):
        self.name = name

defspeak(self):
return"Some sound"


# 子类：Dog 继承 Animal
classDog(Animal):
defbark(self):
return"Woof!"


# 使用示例
my_dog = Dog("Buddy")
print(my_dog.name)       # 输出：Buddy (继承自父类的属性)
print(my_dog.speak())    # 输出：Some sound (继承自父类的方法)
print(my_dog.bark())     # 输出：Woof! (子类独有的方法)

Dog 的实例 my_dog 可以直接使用父类 Animal 的 name 属性和 speak 方法，完美展现了继承的代码复用能力。

3. 多继承

Python 支持多继承，即一个子类可以同时继承多个父类。

语法：class ChildClass(ParentClass1, ParentClass2, ...):

classSwimmer:
defswim(self):
return"I can swim."


classFlyer:
deffly(self):
return"I can fly."


classDuck(Swimmer, Flyer):  # Duck 同时继承 Swimmer 和 Flyer
pass


donald = Duck()
print(donald.swim())  # 输出：I can swim.
print(donald.fly())   # 输出：I can fly.

Duck 类同时拥有了 Swimmer 和 Flyer 的能力。Python 会按照特定的 方法解析顺序（MRO） 来查找方法，在简单场景下，我们只需知道子类可以访问所有父类的方法。

4. 使用 super() 方法

在子类中，我们经常需要调用父类的方法，尤其是在初始化时。super() 函数返回一个代理对象，允许我们方便地调用父类的方法。

典型场景：在子类的 __init__ 方法中初始化父类的属性。

classAnimal:
def__init__(self, name):
        self.name = name
print(f"Animal {self.name} initialized.")


classDog(Animal):
def__init__(self, name, breed):
# 调用父类的 __init__ 方法来初始化 name 属性
super().__init__(name)  # 推荐使用 super()
        self.breed = breed
print(f"Dog {self.name} of breed {self.breed} initialized.")


my_dog = Dog("Buddy", "Golden Retriever")
# 输出：
# Animal Buddy initialized.
# Dog Buddy of breed Golden Retriever initialized.
print(my_dog.name)   # 输出：Buddy
print(my_dog.breed)  # 输出：Golden Retriever

为何选择 super()？
它使代码更通用、更灵活。当父类名改变或继承关系变得复杂（如多层继承）时，使用 super() 能自动找到正确的父类，而使用 ParentClass.__init__(self) 则需要硬编码父类名，维护性较差。

5. 多层继承

继承可以形成一条链：子类可以进一步被另一个类继承，从而构建多层的类体系。

classVehicle:
defgeneral_usage(self):
return"Transportation"


classCar(Vehicle):
defspecific_usage(self):
return"Road travel"


classElectricCar(Car):  # 继承链：Vehicle <- Car <- ElectricCar
defpower_source(self):
return"Battery"


my_tesla = ElectricCar()
print(my_tesla.general_usage())  # 输出：Transportation (继承自 Vehicle)
print(my_tesla.specific_usage()) # 输出：Road travel (继承自 Car)
print(my_tesla.power_source())   # 输出：Battery (自身方法)

ElectricCar 对象可以访问 Car 和 Vehicle 的所有非私有属性和方法，Python 会沿着继承链向上查找。

三、 动手实践：构建你的继承体系

光说不练假把式。现在，请你动手构建一个图形类继承体系，亲身体验代码复用与层次化设计。

任务目标

综合运用单继承与多层继承，创建一组表示几何图形的类，深化对继承价值的理解。

任务描述

1. 创建基类 Shape：

• 包含一个 color（颜色）属性。
• 包含一个 area（计算面积）方法。在基类中，area 方法可以先返回 0。

2. 创建子类 Rectangle 和 Circle：

• 它们都继承自 Shape 类。
• Rectangle
   类需要额外的 width（宽）和 height（高）属性，并重写area 方法来计算矩形面积（公式：宽 × 高）。
• Circle
   类需要额外的 radius（半径）属性，并重写area 方法来计算圆形面积（公式：π × 半径²，π 可取 3.14159）。

3. 创建 Square 类：

• 它继承自 Rectangle 类。
• 思考：正方形是一种特殊的矩形，它只需要一个边长属性。如何利用继承来简化代码？（提示：在 __init__ 方法中调用父类的初始化方法，并将 width 和 height 都设置为这个边长值。）

分步指南

1. 定义 Shape 基类
   在 __init__ 中设置颜色；area 方法返回 0。
2. 实现 Rectangle 与 Circle
• 使用 super().__init__(color) 来初始化颜色属性。
• 添加各自的额外属性（宽高/半径）。
• 重写 area 方法，实现各自的计算逻辑。
3. 实现 Square 类
• 继承 Rectangle。
• 在 __init__ 中调用 super().__init__(color, side, side)，使宽和高都等于传入的边长。
4. 测试验证
   实例化各个类的对象，并打印它们的颜色和面积。

✅ 验收标准

• 代码能够正确运行，无语法错误。
• 能成功创建 Shape、Rectangle、Circle、Square 的对象。
• Square
   对象能通过从 Rectangle 继承的 area 方法正确计算出面积。
• 运行以下测试代码，应得到类似的输出：

# （请将你的类定义代码放在此处之后运行测试）

rect = Rectangle("蓝色", 5, 3)
print(f"{rect.color}矩形面积: {rect.area()}")  # 输出：蓝色矩形面积: 15

circle = Circle("红色", 4)
print(f"{circle.color}圆形面积: {circle.area():.2f}")  # 输出：红色圆形面积: 50.27

square = Square("绿色", 6)
print(f"{square.color}正方形面积: {square.area()}")  # 输出：绿色正方形面积: 36

四、 总结

通过本文的学习，我们掌握了 Python 中类继承这一强大工具的核心内容：

• 核心价值
  继承极大地提高了代码的复用率和程序结构的可维护性，是构建清晰、健壮软件系统的基石。
• 关键点回顾
• 单继承
  通过 class Child(Parent): 实现，子类获得父类的全部功能。
• 多继承
  Python 支持一个类继承多个父类（class Child(ParentA, ParentB):），使用时需注意设计的合理性。
• super() 函数
  是在子类中调用父类方法的推荐方式，尤其在 __init__ 中初始化父类属性时，它使代码更灵活、更健壮。
• 多层继承
  形成了清晰的类层次结构，属性与方法沿着继承链向上查找。
• 设计心法
  合理的继承关系设计（基于 “是一个” 关系）比技术细节更重要。过度或不合理的继承会导致代码难以理解和维护。

五、 附录：核心知识点速查