Python 继承与多态

1. 继承 (Inheritance)

基本概念

继承允许一个类（子类）继承另一个类（父类）的属性和方法

基本语法

python
class ParentClass:
    # 父类定义
    pass

class ChildClass(ParentClass):
    # 子类定义
    pass

2. 继承示例

基础继承

python
class Animal:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def eat(self):
        return f"{self.name}正在吃东西"
    
    def sleep(self):
        return f"{self.name}正在睡觉"

class Dog(Animal):  # Dog类继承Animal类
    def bark(self):
        return f"{self.name}在汪汪叫"

class Cat(Animal):  # Cat类继承Animal类
    def meow(self):
        return f"{self.name}在喵喵叫"

# 使用示例
dog = Dog("旺财", 3)
cat = Cat("咪咪", 2)

print(dog.eat())    # 继承自Animal类
print(dog.bark())   # Dog类自己的方法
print(cat.sleep())  # 继承自Animal类
print(cat.meow())   # Cat类自己的方法

方法重写 (Override)

python
class Animal:
    def __init__(self, name):
        self.name = name
    
    def make_sound(self):
        return "动物发出声音"

class Dog(Animal):
    def make_sound(self):  # 重写父类方法
        return "汪汪汪！"

class Cat(Animal):
    def make_sound(self):  # 重写父类方法
        return "喵喵喵！"

# 测试
animals = [Dog("小黑"), Cat("小白")]

for animal in animals:
    print(f"{animal.name}: {animal.make_sound()}")

3. 多态 (Polymorphism)

多态概念

多态是指不同的类对象对同一消息做出不同的响应

python
class Shape:
    def area(self):
        pass
    
    def perimeter(self):
        pass

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)

class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        return 3.14159 * self.radius ** 2
    
    def perimeter(self):
        return 2 * 3.14159 * self.radius

class Triangle(Shape):
    def __init__(self, a, b, c):
        self.a = a
        self.b = b
        self.c = c
    
    def area(self):
        # 使用海伦公式
        s = (self.a + self.b + self.c) / 2
        return (s * (s - self.a) * (s - self.b) * (s - self.c)) ** 0.5
    
    def perimeter(self):
        return self.a + self.b + self.c

# 多态演示
def print_shape_info(shape):
    """这个函数可以处理任何Shape子类的对象"""
    print(f"面积: {shape.area():.2f}")
    print(f"周长: {shape.perimeter():.2f}")
    print("-" * 20)

# 创建不同形状的对象
shapes = [
    Rectangle(5, 3),
    Circle(4),
    Triangle(3, 4, 5)
]

for shape in shapes:
    print_shape_info(shape)

4. 继承的进阶特性

super() 函数

python
class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age
    
    def introduce(self):
        return f"我叫{self.name}，今年{self.age}岁"

class Student(Person):
    def __init__(self, name, age, student_id):
        super().__init__(name, age)  # 调用父类的__init__
        self.student_id = student_id
    
    def introduce(self):
        # 扩展父类方法
        base_intro = super().introduce()
        return f"{base_intro}，学号是{self.student_id}"

class Teacher(Person):
    def __init__(self, name, age, subject):
        super().__init__(name, age)
        self.subject = subject
    
    def introduce(self):
        base_intro = super().introduce()
        return f"{base_intro}，我教{self.subject}"

# 使用
student = Student("小明", 18, "2023001")
teacher = Teacher("张老师", 35, "数学")

print(student.introduce())
print(teacher.introduce())

多重继承

python
class Flyable:
    def fly(self):
        return "我能飞"

class Swimmable:
    def swim(self):
        return "我能游泳"

class Duck(Flyable, Swimmable):
    def __init__(self, name):
        self.name = name
    
    def quack(self):
        return "嘎嘎嘎"

duck = Duck("唐老鸭")
print(duck.fly())    # 来自Flyable
print(duck.swim())   # 来自Swimmable
print(duck.quack())  # 自己的方法

5. 类型检查和抽象基类

isinstance() 和 issubclass()

python
class Animal:
    pass

class Dog(Animal):
    pass

class Cat(Animal):
    pass

# 类型检查
dog = Dog()
cat = Cat()

print(isinstance(dog, Dog))      # True
print(isinstance(dog, Animal))   # True
print(isinstance(dog, Cat))      # False

print(issubclass(Dog, Animal))   # True
print(issubclass(Cat, Animal))   # True
print(issubclass(Dog, Cat))      # False

抽象基类 (ABC)

python
from abc import ABC, abstractmethod

class Vehicle(ABC):  # 抽象基类
    @abstractmethod
    def start_engine(self):
        pass
    
    @abstractmethod
    def stop_engine(self):
        pass
    
    def honk(self):  # 具体方法
        return "喇叭响！"

class Car(Vehicle):
    def start_engine(self):
        return "汽车引擎启动"
    
    def stop_engine(self):
        return "汽车引擎停止"

class Motorcycle(Vehicle):
    def start_engine(self):
        return "摩托车引擎启动"
    
    def stop_engine(self):
        return "摩托车引擎停止"

# 使用
vehicles = [Car(), Motorcycle()]

for vehicle in vehicles:
    print(vehicle.start_engine())
    print(vehicle.honk())
    print(vehicle.stop_engine())
    print("-" * 20)

6. 实际应用案例

员工管理系统

python
class Employee:
    def __init__(self, name, employee_id, base_salary):
        self.name = name
        self.employee_id = employee_id
        self.base_salary = base_salary
    
    def calculate_salary(self):
        return self.base_salary
    
    def get_info(self):
        return f"员工: {self.name} (ID: {self.employee_id})"

class Manager(Employee):
    def __init__(self, name, employee_id, base_salary, bonus):
        super().__init__(name, employee_id, base_salary)
        self.bonus = bonus
    
    def calculate_salary(self):
        return self.base_salary + self.bonus
    
    def manage_team(self):
        return f"{self.name}正在管理团队"

class Developer(Employee):
    def __init__(self, name, employee_id, base_salary, programming_language):
        super().__init__(name, employee_id, base_salary)
        self.programming_language = programming_language
    
    def calculate_salary(self):
        # 开发者有10%的技术津贴
        return self.base_salary * 1.1
    
    def code(self):
        return f"{self.name}正在用{self.programming_language}编写代码"

class Intern(Employee):
    def __init__(self, name, employee_id, base_salary, university):
        super().__init__(name, employee_id, base_salary)
        self.university = university
    
    def calculate_salary(self):
        # 实习生工资是基本工资的80%
        return self.base_salary * 0.8
    
    def study(self):
        return f"{self.name}正在学习，来自{self.university}"

# 使用多态处理员工
def process_employees(employees):
    total_salary = 0
    
    for employee in employees:
        print(employee.get_info())
        print(f"工资: {employee.calculate_salary():.2f}")
        
        # 调用特定类型的方法
        if isinstance(employee, Manager):
            print(employee.manage_team())
        elif isinstance(employee, Developer):
            print(employee.code())
        elif isinstance(employee, Intern):
            print(employee.study())
        
        total_salary += employee.calculate_salary()
        print("-" * 30)
    
    print(f"总工资支出: {total_salary:.2f}")

# 创建员工列表
employees = [
    Manager("张总", "M001", 15000, 5000),
    Developer("李工", "D001", 12000, "Python"),
    Developer("王工", "D002", 13000, "Java"),
    Intern("小明", "I001", 4000, "清华大学")
]

process_employees(employees)

7. 鸭子类型 (Duck Typing)

Python的多态更多基于鸭子类型而不是严格的继承关系

python
# 不依赖于继承的多态
class PDFGenerator:
    def generate(self, data):
        return f"生成PDF: {data}"

class HTMLGenerator:
    def generate(self, data):
        return f"生成HTML: {data}"

class CSVGenerator:
    def generate(self, data):
        return f"生成CSV: {data}"

# 使用鸭子类型 - 只要对象有generate方法就可以
def export_data(generator, data):
    """导出数据，不关心generator的具体类型"""
    return generator.generate(data)

# 测试
generators = [PDFGenerator(), HTMLGenerator(), CSVGenerator()]
data = "一些数据"

for generator in generators:
    print(export_data(generator, data))

总结

继承的优点：

• 代码重用
• 层次化组织代码
• 易于维护和扩展

多态的优点：

• 接口统一
• 代码灵活性
• 易于扩展新功能

使用原则：

1. 使用继承建立"is-a"关系
2. 优先使用组合而非多重继承
3. 利用多态编写通用代码
4. 遵循里氏替换原则：子类应该能够替换父类