Python案例怎么实现方法重写？

wen python案例 2026-06-11 16

Python案例：一文掌握方法重写的实现原理与最佳实践

目录导读

什么是方法重写？——从面向对象基础说起
方法重写的核心语法与规则
案例1：经典动物继承体系中的重写
案例2：使用super()调用父类被重写的方法
案例3：多态特性下的方法重写应用
案例4：重写__str__和__repr__特殊方法
常见陷阱与错误排查
问答环节：高频面试题与实战答疑

什么是方法重写？——从面向对象基础说起

方法重写（Method Overriding) 是Python面向对象编程中子类重新定义父类已有方法的机制，当子类继承父类后，如果父类的方法不能满足子类的特定需求,子类可以编写一个同名方法覆盖父类的实现。

Python案例怎么实现方法重写？

核心特点：

发生在继承关系中

子类方法签名（名称+参数）与父类一致

调用时优先执行子类版本

为什么需要方法重写？
假设有一个Animal父类，所有动物都会发出声音，但狗叫是“汪汪”，猫叫是“喵喵”，如果父类写死了“动物叫”，显然不合理——通过重写，每个子类可以有自己的“叫声”。

方法重写的核心语法与规则

1 基础语法

class Parent:
    def method(self):
        print("父类方法")
class Child(Parent):
    def method(self):          # 重写父类方法
        print("子类重写后的方法")

2 必须遵守的规则

方法名必须完全相同（包括参数个数和顺序）
访问权限：Python没有私有/公开的强制限制，但习惯上重写的方法保持相同可见性
返回值类型：Python是动态类型，没有强制要求，但建议保持一致
不能重写__init__：实际上可以，但通常不推荐；子类初始化应使用super().__init__()

3 与“方法重载”的区别

特性	方法重写（Override）	方法重载（Overload）
关系	父子类间	同一类中
方法名	相同	相同
参数	相同	不同参数
Python支持	原生支持	不支持（需`@singledispatch`模拟）

案例1：经典动物继承体系中的重写

让我们编写一个完整的动物声音示例：

class Animal:
    def __init__(self, name):
        self.name = name
    def speak(self):
        return f"{self.name} 发出了一种未知的声音"
class Dog(Animal):
    def speak(self):  # 重写父类speak方法
        return f"{self.name} 汪汪叫"
class Cat(Animal):
    def speak(self):  # 重写父类speak方法
        return f"{self.name} 喵喵叫"
# 测试
animals = [Dog("旺财"), Cat("咪咪"), Animal("无名")]
for animal in animals:
    print(animal.speak())
# 输出：
# 旺财 汪汪叫
# 咪咪 喵喵叫
# 无名 发出了一种未知的声音

要点解析：

子类Dog和Cat分别重写了speak()方法
当遍历列表时，Python根据对象的实际类型（运行时类型）调用对应的方法——这就是动态分派

案例2：使用`super()`调用父类被重写的方法

有时你需要在子类中扩展父类方法，而不是完全替换。super()函数允许你在子类中显式调用父类版本。

1 扩展构造函数的典型场景

class Vehicle:
    def __init__(self, brand, model):
        self.brand = brand
        self.model = model
        print(f"Vehicle __init__: {brand} {model}")
class Car(Vehicle):
    def __init__(self, brand, model, doors):
        super().__init__(brand, model)  # 调用父类构造函数
        self.doors = doors
        print(f"Car __init__: {doors} doors")
# 测试
my_car = Car("Tesla", "Model 3", 4)
# 输出:
# Vehicle __init__: Tesla Model 3
# Car __init__: 4 doors

2 重写普通方法时调用父类

class Shape:
    def area(self):
        return 0
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    def area(self):
        # 调用父类的area（虽然这里返回0，但体现扩展模式）
        parent_area = super().area()
        return 3.14 * self.radius ** 2 + parent_area
print(Circle(5).area())  # 78.5

注意：

使用super()时不要传递self，Python自动处理
在多继承中，super()遵循MRO（方法解析顺序）

案例3：多态特性下的方法重写应用

多态（Polymorphism）允许不同对象响应相同消息,方法重写是实现多态的关键。

1 定义统一接口

class PaymentProcessor:
    def process(self, amount):
        raise NotImplementedError("子类必须实现此方法")
class AliPay(PaymentProcessor):
    def process(self, amount):
        print(f"支付宝支付 {amount} 元")
class WeChatPay(PaymentProcessor):
    def process(self, amount):
        print(f"微信支付 {amount} 元")
class BankTransfer(PaymentProcessor):
    def process(self, amount):
        print(f"银行转账 {amount} 元")
# 多态调用
def execute_payment(payment_method, amount):
    payment_method.process(amount)
payments = [AliPay(), WeChatPay(), BankTransfer()]
for pm in payments:
    execute_payment(pm, 100)  # 同一接口，不同行为

2 多态的好处

代码可扩展：新增支付方式只需定义新类重写process()
解耦：execute_payment函数不依赖具体实现类

案例4：重写`str`和`repr`特殊方法

Python内置的“双下划线”方法可以重写,改变对象在字符串格式化中的行为。

1 `str` vs `repr`

__str__：面向用户的可读性输出（print()调用）
__repr__：面向开发者的调试输出（repr()调用,交互式环境默认）

class Book:
    def __init__(self, title, author, year):
        self.title = title
        self.author = author
        self.year = year
    def __str__(self):
        return f"《{self.title}》- {self.author}"
    def __repr__(self):
        return f"Book('{self.title}', '{self.author}', {self.year})"
book = Book("Python编程", "张三", 2023)
print(book)          # 《Python编程》- 张三
print(repr(book))    # Book('Python编程', '张三', 2023)

2 其他可重写的特殊方法

__len__：让len()起作用
__eq__：自定义相等比较
__lt__：自定义小于比较

常见陷阱与错误排查

❌ 陷阱1：参数不一致

class Parent:
    def greet(self, name):
        print(f"Hello {name}")
class Child(Parent):
    def greet(self):  # 少了一个参数
        print("Hello")
# 调用时可能会出错
c = Child()
c.greet("Alice")  # TypeError: greet() takes 1 positional argument but 2 were given

解决：确保参数列表完全匹配，或者使用*args, **kwargs保持灵活

❌ 陷阱2：忘记调用`super().init()`

class Parent:
    def __init__(self):
        self.value = 42
class Child(Parent):
    def __init__(self):
        # 没有调用super().__init__()
        self.value = 100
c = Child()
print(c.value)  # 100，但父类初始化被跳过，可能丢失重要状态

❌ 陷阱3：私有属性混淆

class Parent:
    def __init__(self):
        self.__secret = "Parent secret"  # name mangling为 _Parent__secret
class Child(Parent):
    def show_secret(self):
        print(self.__secret)  # 实际查找 _Child__secret，报错
c = Child()
c.show_secret()  # AttributeError

问答环节：高频面试题与实战答疑

Q1：方法重写和继承有什么关系？

A：继承是重写的前提，只有子类继承了父类，才能重写父类方法，重写的本质是子类提供自己的方法实现来覆盖从父类继承来的实现。

Q2：为什么重写时要使用`super()`？

A：当你需要在子类中扩展父类功能，而不是完全替换时，使用super()可以调用父类的原始方法，避免重复代码，子类的__init__中调用super().__init__()可以初始化父类的属性。

Q3：Python支持方法重载吗？如何实现类似效果？

A：Python原生不支持方法重载（即同一个类中多个同名方法不同参数）,但可以通过以下方式模拟：

使用默认参数：def method(self, a=None, b=None)
使用*args和**kwargs
使用functools.singledispatch实现单分派泛型函数

Q4：重写和隐藏（方法遮蔽）有什么区别？

A：在Python中，子类重写父类方法时，父类方法被覆盖（Override），使用子类实例调用时永远不会执行父类版本（除非通过super()），而“隐藏”（Hide）通常指通过类名调用时，子类方法隐藏了父类同名方法，但Python中不会出现真正意义上的隐藏——因为Python的方法查找总是从当前类开始。

Q5：如何强制子类必须重写某个方法？

A：使用抽象基类（ABC）：

from abc import ABC, abstractmethod
class AbstractShape(ABC):
    @abstractmethod
    def area(self):
        pass
class Triangle(AbstractShape):
    # 如果不实现area()，实例化时会报错
    pass
# TypeError: Can't instantiate abstract class Triangle with abstract methods area

Q6：重写静态方法和类方法可以吗？

A：可以，静态方法和类方法也能被重写,但需要注意调用方式：

class Parent:
    @staticmethod
    def info():
        return "Parent"
class Child(Parent):
    @staticmethod
    def info():
        return "Child"
print(Child.info())  # 输出 "Child"
print(Parent.info()) # 输出 "Parent"

方法重写是Python面向对象编程的核心机制之一，它实现了多态、代码复用和灵活扩展，通过上述案例,你学会了：