异常教程

Python 定义一个子类继承父类，并在子类中重写一个方法（手把手讲解）

更新时间:

💡一则或许对你有用的小广告

欢迎加入小哈的星球 ，你将获得：专属的项目实战 / 1v1 提问 / Java 学习路线 / 学习打卡 / 每月赠书 / 社群讨论

截止目前， 星球 内专栏累计输出 90w+ 字，讲解图 3441+ 张，还在持续爆肝中.. 后续还会上新更多项目，目标是将 Java 领域典型的项目都整一波，如秒杀系统, 在线商城, IM 即时通讯，权限管理，Spring Cloud Alibaba 微服务等等，已有 3100+ 小伙伴加入学习 ，欢迎点击围观

在面向对象编程（OOP）中，Python 定义一个子类继承父类，并在子类中重写一个方法是实现代码复用和扩展功能的核心机制之一。对于编程初学者而言，这像是学习“如何站在巨人的肩膀上继续建造高楼”；对于中级开发者，这则是优化代码结构、提升代码灵活性的关键工具。本文将通过循序渐进的方式，结合生活化比喻和实战案例，深入解析这一主题的核心概念与实现技巧。

继承：从“遗传”到“代码复用”的桥梁

什么是继承？

继承（Inheritance）是面向对象编程中的四大核心特性之一（其他三个是封装、多态、抽象）。它允许一个类（子类）继承另一个类（父类）的属性和方法，就像生物学中的“遗传”一样。例如，狗和猫都属于“动物”这一大类，因此它们可以继承“动物”类的通用行为（如eat()方法），同时保留各自独特的特征（如狗的bark()方法）。

父类与子类的关系

  • 父类（基类/超类）：提供基础属性和方法的类，相当于“模板”。
  • 子类（派生类）：继承父类的类，可以添加或修改父类的功能。

代码示例：定义父类和子类

class Animal:  # 父类  
    def __init__(self, name):  
        self.name = name  

    def eat(self):  
        print(f"{self.name} is eating.")  

class Dog(Animal):  # 子类继承父类  
    def bark(self):  
        print(f"{self.name} says: Woof!")  

dog = Dog("Buddy")  
dog.eat()    # 继承父类的 eat() 方法  
dog.bark()   # 子类独有的方法

继承的优势

  1. 代码复用：避免重复编写相同的功能。
  2. 扩展性：子类可以在不修改父类代码的前提下，添加新功能。
  3. 层级结构清晰：通过继承关系，代码的组织更符合现实世界的逻辑。

重写方法：在子类中“个性化”父类行为

什么是方法重写？

方法重写（Method Overriding）是指子类重新定义从父类继承的方法，使其在子类中表现出不同的行为。这类似于生物学中“基因突变”——子类保留父类的某些特性，但通过重写方法实现“个性化”。

方法重写的条件

  • 方法名必须相同：子类方法与父类方法的名称和参数列表一致。
  • 继承关系存在：子类必须明确继承父类。

重写方法的步骤

  1. 定义父类的方法：确保父类中存在需要被重写的方法。
  2. 在子类中重新定义同名方法：使用相同的方法名和参数。
  3. 调用父类方法（可选）：通过super()保留父类逻辑，再添加子类的特殊逻辑。

代码示例：简单重写方法

class Animal:  
    def eat(self):  
        print("Animal is eating generic food.")  

class Cat(Animal):  
    def eat(self):  # 重写父类的 eat() 方法  
        print("Cat is eating fish.")  

cat = Cat()  
cat.eat()  # 输出：Cat is eating fish.

为什么需要重写方法？

  • 实现多态性：不同子类对同一方法有不同的表现（例如，Dog.bark()和Cat.meow()）。
  • 覆盖不适用的父类逻辑：例如，父类的compute_area()方法对圆形和矩形的面积计算方式不同。

使用 super()：连接父类与子类的纽带

super() 的作用

super() 是 Python 中用于调用父类方法的关键函数。它允许子类在重写方法时，既保留父类的原有逻辑，又能添加自己的扩展。

比喻：
想象你继承了一间老房子（父类），并打算在院子里加建一个花园（子类的扩展）。通过super()，你可以先保留老房子的结构（父类方法），再在旁边新建花园（子类新增逻辑）。

代码示例：使用 super() 调用父类方法

class Vehicle:  
    def __init__(self, brand):  
        self.brand = brand  

    def start_engine(self):  
        print(f"{self.brand}'s engine is starting...")  

class ElectricCar(Vehicle):  
    def __init__(self, brand, battery_size):  
        super().__init__(brand)  # 调用父类的 __init__  
        self.battery_size = battery_size  

    def start_engine(self):  
        super().start_engine()   # 继承父类的启动逻辑  
        print(f"Electric motor is charging with {self.battery_size} kWh.")  

tesla = ElectricCar("Tesla", 100)  
tesla.start_engine()

super() 的注意事项

  • 必须与方法名配合使用：例如，super().method_name()。
  • 适用于多重继承：在复杂的继承链中，super() 能按 MRO（方法解析顺序）自动调用父类方法。

实战案例：通过继承与重写构建灵活的类结构

案例背景

假设我们要设计一个“形状计算器”，包含矩形、圆形等子类，每个子类需要重写父类的calculate_area()方法。

步骤 1：定义父类

class Shape:  
    def __init__(self, name):  
        self.name = name  

    def calculate_area(self):  
        raise NotImplementedError(  
            "Subclasses must implement calculate_area() method."  
        )

说明：

  • 父类Shape定义了一个抽象方法calculate_area()，强制要求子类必须实现该方法。
  • raise NotImplementedError 是一种常见的“占位符”，避免父类被直接实例化。

步骤 2：定义子类

class Rectangle(Shape):  
    def __init__(self, name, length, width):  
        super().__init__(name)  
        self.length = length  
        self.width = width  

    def calculate_area(self):  
        return self.length * self.width  

class Circle(Shape):  
    def __init__(self, name, radius):  
        super().__init__(name)  
        self.radius = radius  

    def calculate_area(self):  
        return 3.14 * (self.radius ** 2)

步骤 3：使用多态性

def print_area(shape):  
    print(f"{shape.name}'s area is: {shape.calculate_area()}")  

rect = Rectangle("Rectangle", 5, 10)  
circle = Circle("Circle", 7)  

print_area(rect)   # 输出：Rectangle's area is: 50  
print_area(circle) # 输出：Circle's area is: 153.86

案例总结

  • 继承使Rectangle和Circle共享了name属性和calculate_area()方法的框架。
  • 重写让每个子类根据自身特性实现calculate_area()，从而实现多态性。

注意事项与常见问题

常见错误及解决方案

错误类型表现解决方案
方法名不匹配子类方法名与父类不同，导致未重写确保方法名和参数列表完全一致
忘记调用父类初始化子类未通过super().__init__()调用父类构造方法在子类__init__中显式调用父类初始化
拼写错误例如将calculate_area误写为calculat_area使用IDE的代码检查功能，或通过单元测试验证

设计原则

  1. 单一职责原则：父类应专注于通用功能，子类负责特定实现。
  2. 开闭原则：对扩展开放，对修改关闭——通过继承而非修改父类来添加新功能。

进阶应用：抽象基类与接口设计

在 Python 中，可以使用 abc 模块定义抽象基类（Abstract Base Class），强制子类实现特定方法。例如：

from abc import ABC, abstractmethod  

class Animal(ABC):  
    @abstractmethod  
    def make_sound(self):  
        pass  

class Dog(Animal):  
    def make_sound(self):  
        return "Woof!"

抽象基类的优势：

  • 确保所有子类必须实现关键方法，避免逻辑漏洞。
  • 支持动态类型检查，例如 isinstance(obj, Animal)。

结论

通过本文的讲解，我们已经掌握了 Python 定义一个子类继承父类，并在子类中重写一个方法 的核心技巧。这一机制不仅简化了代码结构，还为灵活扩展提供了无限可能。

对于初学者，建议从简单的继承案例入手，逐步实践重写方法和super()的使用；对于中级开发者，可以探索抽象基类、多继承等高级特性。记住，面向对象编程的精髓在于“用对象的组合与继承，模拟真实世界的逻辑关系”。

未来，你可以进一步研究：

  • 多重继承与 MRO（方法解析顺序）
  • 使用装饰器增强类功能
  • 面向对象设计模式（如工厂模式、策略模式）

通过持续练习与思考，你将逐渐掌握面向对象编程的精髓，写出优雅且高效的代码！

最新发布

查看更多文章