本文目录导读：
在Python中,方法重写（Method Overriding）是面向对象编程的重要特性，子类可以重新定义父类中已有的方法，以下是详细的重写方法和案例：
基本语法
class Parent:
def method(self):
# 父类的实现
pass
class Child(Parent):
def method(self):
# 子类重写父类方法
# 新实现
pass
案例1：基础重写
class Animal:
def speak(self):
return "动物发出声音"
def move(self):
return "动物在移动"
class Dog(Animal):
def speak(self):
return "汪汪汪！"
def move(self):
return "狗在奔跑"
class Cat(Animal):
def speak(self):
return "喵喵喵！"
def move(self):
return "猫在悄悄走"
# 使用
animals = [Animal(), Dog(), Cat()]
for animal in animals:
print(animal.speak(), "|", animal.move())
# 输出：
# 动物发出声音 | 动物在移动
# 汪汪汪！ | 狗在奔跑
# 喵喵喵！ | 猫在悄悄走
案例2：调用父类方法
class Shape:
def __init__(self, color):
self.color = color
def area(self):
return 0
def info(self):
return f"这是一个{self.color}色的形状"
class Circle(Shape):
def __init__(self, color, radius):
# 调用父类构造函数
super().__init__(color)
self.radius = radius
def area(self):
# 重写并调用父类方法
base_area = super().area() # 可以调用父类的原始实现
return 3.14 * self.radius ** 2
def info(self):
# 扩展父类方法的功能
parent_info = super().info()
return f"{parent_info}，半径为{self.radius}的圆"
# 使用
circle = Circle("红色", 5)
print(circle.info()) # 这是一个红色的形状，半径为5的圆
print(f"面积：{circle.area()}") # 面积：78.5
案例3：完全重写（不调用父类）
class Calculator:
def calculate(self, a, b):
return a + b
class AdvancedCalculator(Calculator):
def calculate(self, a, b):
# 完全重写，不调用父类方法
return a * b + a + b # 完全不同的计算逻辑
class StringCalculator(Calculator):
def calculate(self, a, b):
# 完全不同的功能
return f"{a} 和 {b} 的组合"
# 使用
calc = Calculator()
adv_calc = AdvancedCalculator()
str_calc = StringCalculator()
print(calc.calculate(5, 3)) # 8
print(adv_calc.calculate(5, 3)) # 23
print(str_calc.calculate(5, 3)) # 5 和 3 的组合
案例4：重写特殊方法
class Number:
def __init__(self, value):
self.value = value
def __str__(self):
return f"数字：{self.value}"
class EvenNumber(Number):
def __init__(self, value):
if value % 2 != 0:
raise ValueError("必须是偶数")
super().__init__(value)
def __str__(self):
# 重写特殊方法
return f"偶数：{self.value}"
def __add__(self, other):
# 重写加法运算符
if isinstance(other, EvenNumber):
return EvenNumber(self.value + other.value)
return NotImplemented
# 使用
num1 = EvenNumber(4)
num2 = EvenNumber(6)
print(num1) # 偶数：4
print(num1 + num2) # 偶数：10
案例5：多层继承重写
class Vehicle:
def start(self):
return "车辆启动"
def stop(self):
return "车辆停止"
class Car(Vehicle):
def start(self):
return "汽车启动，发动机轰鸣"
def park(self):
return "汽车正在停车"
class ElectricCar(Car):
def start(self):
# 重写并调用祖父类方法
vehicle_start = super(Car, self).start() # 调用Vehicle的start
return f"电动车静音启动，{vehicle_start}"
def stop(self):
# 重写父类方法
return "电动车刹车能量回收"
# 使用
tesla = ElectricCar()
print(tesla.start()) # 电动车静音启动，车辆启动
print(tesla.stop()) # 电动车刹车能量回收
print(tesla.park()) # 汽车正在停车
重要注意事项
参数一致性
class Base:
def process(self, data, multiplier=1):
return data * multiplier
class Child(Base):
# 推荐：保持签名一致
def process(self, data, multiplier=1):
return super().process(data, multiplier) * 2
# 不推荐：改变签名可能会引起问题
# def process(self, data, multiplier=1, additional=0):
# return data * multiplier + additional
使用super()的推荐方式
class Parent:
def method(self):
print("Parent method")
class Child(Parent):
def method(self):
# Python 3 推荐方式
super().method()
print("Child additional code")
# 或者使用类名（不推荐，但兼容旧版本）
# Parent.method(self)
抽象方法重写
from abc import ABC, abstractmethod
class AbstractShape(ABC):
@abstractmethod
def area(self):
pass
class Square(AbstractShape):
def __init__(self, side):
self.side = side
def area(self): # 必须重写
return self.side ** 2
调试技巧
class Logger:
def action(self):
print("父类方法执行")
class DebugLogger(Logger):
def action(self):
# 使用breakpoint()或print调试
print(f"调用者：{self.__class__.__name__}")
print("准备调用父类方法")
result = super().action()
print("父类方法执行完毕")
return result
# 使用
dl = DebugLogger()
dl.action()
# 输出：
# 调用者：DebugLogger
# 准备调用父类方法
# 父类方法执行
# 父类方法执行完毕
掌握方法重写是Python OOP编程的基础，合理使用可以提高代码的复用性和可维护性。
