Python面向对象编程：继承与多态实用指南

1. 继承基础

面向对象编程（OOP）的魅力之一，就在于继承这个核心特性：它允许我们站在「巨人的肩膀」上开发——基于已有的「父类（基类/超类）」快速创建「子类（派生类）」，自动复用父类的所有属性和方法，同时灵活扩展或修改特定功能。

1.1 极简继承语法

Python 的继承语法非常直观，只需在子类定义的括号里填入要继承的父类名称即可：

class ParentClass:
    # 父类的属性、方法定义
    pass

class ChildClass(ParentClass):
    # 子类的扩展/修改定义
    pass

1.2 具象继承场景

用最经典的「动物分类」场景举个例子：先定义所有动物共有的属性和通用行为，再细分不同动物的专属行为：

# 父类：定义所有动物的通用属性（名字）和通用行为（发出声音）
class Animal:
    def __init__(self, name):
        self.name = name  # 名字：所有动物都有的属性
        
    def speak(self):
        print(f"{self.name} makes a generic sound")  # 通用叫声

# 子类1：狗，继承Animal
class Dog(Animal):
    # 重写（覆盖）通用的speak方法，改成狗的专属行为
    def speak(self):
        print(f"{self.name} barks: Woof Woof!")

# 子类2：猫，同样继承Animal
class Cat(Animal):
    # 重写通用speak方法
    def speak(self):
        print(f"{self.name} meows: Meow Meow~")

2. 继承带来的直接好处

2.1 代码复用，减少冗余

如果没有继承，我们是不是要给Dog、Cat、Bird都单独写一遍__init__设置名字？但有了继承后，这部分代码直接由子类「拿来主义」，我们只需要关注不同的地方：

# 调用父类的通用方法（可选重写的情况）
generic_animal = Animal("无名小兽")
generic_animal.speak()  # 输出：无名小兽 makes a generic sound

# 调用子类自己重写的方法
buddy = Dog("Buddy")
buddy.speak()  # 输出：Buddy barks: Woof Woof!

whiskers = Cat("Whiskers")
whiskers.speak()  # 输出：Whiskers meows: Meow Meow~

2.2 灵活扩展功能

除了重写方法，子类还可以新增专属属性或方法，完全不影响父类和其他兄弟类：

# 新增鸟类，继承Animal
class Bird(Animal):
    # 1. 重写通用speak
    def speak(self):
        print(f"{self.name} chirps: Tweet Tweet♪")
    
    # 2. 新增专属方法：飞行
    def fly(self, height="low"):
        print(f"{self.name} is flying {height} in the sky~")

# 测试专属方法
tweety = Bird("Tweety")
tweety.speak()  # 通用部分的重写生效
tweety.fly("high")  # 专属方法只能由Bird实例调用

3. 多态性：同一个接口，不同的响应

理解了继承，再看多态就简单了——它指的是不同类的对象，调用「名字完全相同」的方法时，会执行各自的专属实现，就像给所有动物发「张嘴叫」的指令，狗会汪汪、猫会喵喵、鸟会叽叽喳喳。

3.1 经典多态示例

我们可以写一个「通用调用函数」，完全不需要考虑传入的具体是什么类型的对象，只要它有speak方法就行：

def make_it_speak(thing):
    # 不管thing是什么，只要能speak就执行
    thing.speak()

# 把不同类的实例放到一个列表里
mixed_things = [Dog("Rex"), Cat("Mittens"), Bird("Tweety")]

# 遍历列表，统一调用make_it_speak
for thing in mixed_things:
    make_it_speak(thing)

这段代码的输出是不是非常直观？

Rex barks: Woof Woof!
Mittens meows: Meow Meow~
Tweety chirps: Tweet Tweet♪

3.2 多态背后的「开闭原则」

多态完美贴合了OOP的黄金法则之一——开闭原则（Open/Closed Principle）：

✅ 对扩展开放：如果想新增一种Fish类，只需要继承Animal重写speak，不用改make_it_speak这个通用函数
❌ 对修改封闭：现有依赖父类的代码（比如通用函数、列表遍历）完全不用碰

4. 简单的类型检查

虽然Python是动态语言，对类型的约束比较松，但有时我们需要明确知道「某个对象是不是某个类的实例」「某个类是不是继承自另一个类」，这时候就可以用两个内置函数：

4.1 `isinstance()`：检查实例类型

rex = Dog("Rex")

# 检查rex是不是Dog的实例（直接类型）
print(isinstance(rex, Dog))    # True
# 检查rex是不是Animal的实例（继承类型）
print(isinstance(rex, Animal)) # True
# 检查rex是不是Cat的实例（无关类型）
print(isinstance(rex, Cat))    # False

4.2 `issubclass()`：检查类的继承关系

# 检查Dog是不是继承自Animal
print(issubclass(Dog, Animal)) # True
# 检查Animal是不是继承自自己（Python的小特性：所有类都是自己的子类）
print(issubclass(Animal, Animal)) # True
# 检查Animal是不是继承自Dog（反向继承不存在）
print(issubclass(Animal, Dog)) # False

5. Python特有的「鸭子类型」

和Java、C++这些静态语言不同，Python并不强制要求「多态必须基于继承关系」——它奉行「鸭子类型」（Duck Typing）：

如果它走起路来像鸭子，叫起来像鸭子，那它就是鸭子！

换句话说，Python只关心对象「有没有需要的方法」，不关心它「属于哪个类」。我们可以在上面的多态示例里，加一个完全不相关的Car类试试：

# 完全不继承Animal的Car类，但有speak方法
class Car:
    def speak(self):
        print("A car makes a sound: Vroom Vroom!")

# 把Car实例也加到mixed_things里
mixed_things.append(Car())

# 再遍历一遍，通用函数依然能用！
for thing in mixed_things:
    make_it_speak(thing)

新增的输出会是：

A car makes a sound: Vroom Vroom!

6. 几个实用的最佳实践

继承和多态虽然强大，但滥用会导致代码复杂度飙升，这里有4个经验法则：

优先使用「组合」而非「继承」：只有当两个类是「是一种（is-a）」关系时（比如「狗是一种动物」），才用继承；如果是「有一个（has-a）」关系（比如「人有一条狗」），用组合更灵活
尽量避免「多重继承」：Python虽然支持，但多重继承会导致「菱形继承问题」（两个父类继承自同一个祖先，子类调用祖先方法时会混乱），除非有明确的设计需求
用抽象基类（ABC）定义接口规范：如果希望所有子类必须实现某些方法，可以用abc模块定义抽象基类，这样Python会强制约束子类
遵循「里氏替换原则」：子类应该能完全替换父类的位置，而不会导致程序出错（比如父类的speak只打印信息，子类的speak就不要突然删除文件）

6.1 快速看一个抽象基类的例子

抽象基类不能直接实例化，必须被子类继承并实现所有标记了@abstractmethod的方法：

from abc import ABC, abstractmethod

# 定义抽象基类Shape，要求所有形状必须计算面积和周长
class Shape(ABC):
    @abstractmethod  # 强制子类必须实现的方法
    def area(self):
        pass
        
    @abstractmethod
    def perimeter(self):
        pass

# 子类Rectangle，必须实现area和perimeter
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
        
    def area(self):
        return self.width * self.height
        
    def perimeter(self):
        return 2 * (self.width + self.height)

# 实例化成功
rect = Rectangle(3, 4)
print(rect.area())  # 输出：12
print(rect.perimeter())  # 输出：14

# 尝试直接实例化抽象基类会报错
# shape = Shape()  # 这行代码会抛出TypeError

7. 总结

继承和多态是Python OOP的核心框架：

继承：实现代码复用和层次化的类结构，站在巨人肩膀上开发
多态：同一个接口对应不同实现，提高代码的灵活性和可扩展性
鸭子类型：Python的「松约束」特性，让代码更简洁通用

记住，工具没有好坏，合理使用才是关键——优先组合、避免多重继承、用抽象基类做约束，就能写出清晰易维护的面向对象代码！

#Python面向对象编程：继承与多态实用指南

#1. 继承基础

#1.1 极简继承语法

#1.2 具象继承场景

#2. 继承带来的直接好处

#2.1 代码复用，减少冗余

#2.2 灵活扩展功能

#3. 多态性：同一个接口，不同的响应

#3.1 经典多态示例

#3.2 多态背后的「开闭原则」

#4. 简单的类型检查

#4.1 isinstance()：检查实例类型

#4.2 issubclass()：检查类的继承关系

#5. Python特有的「鸭子类型」

#6. 几个实用的最佳实践

#6.1 快速看一个抽象基类的例子

#7. 总结