面向对象编程：继承与多态¶

在面向对象编程（OOP）中，继承和多态是两个核心概念。它们使得代码更加模块化、可重用，并且易于维护。本章将详细介绍Python中的继承机制以及多态的实现方式。

1. 继承¶

1.1 什么是继承？¶

继承是面向对象编程中的一个重要概念，它允许一个类（子类）继承另一个类（父类）的属性和方法。通过继承，子类可以复用父类的代码，并且可以在子类中添加新的属性和方法，或者重写父类的方法。

1.2 继承的基本语法¶

在Python中，继承的语法非常简单。我们只需要在定义子类时，将父类的名称放在子类名称后面的括号中即可。

# 定义一个父类
class Animal:
    def __init__(self, name):
        self.name = name

    def speak(self):
        return f"{self.name} makes a sound."

# 定义一个子类，继承自Animal
class Dog(Animal):
    def bark(self):
        return f"{self.name} barks."

# 创建Dog类的实例
dog = Dog("Buddy")
print(dog.speak())  # 输出: Buddy makes a sound.
print(dog.bark())   # 输出: Buddy barks.

在上面的例子中，Dog类继承了Animal类的__init__方法和speak方法。同时，Dog类还定义了自己的bark方法。

1.3 方法重写¶

子类可以重写父类的方法，以提供不同的实现。

class Cat(Animal):
    def speak(self):
        return f"{self.name} meows."

# 创建Cat类的实例
cat = Cat("Whiskers")
print(cat.speak())  # 输出: Whiskers meows.

在这个例子中，Cat类重写了Animal类的speak方法，使得Cat类的实例在调用speak方法时，输出的是“meows”而不是“makes a sound”。

1.4 多重继承¶

Python支持多重继承，即一个子类可以继承多个父类。

class A:
    def method_a(self):
        return "Method A"

class B:
    def method_b(self):
        return "Method B"

class C(A, B):
    pass

# 创建C类的实例
c = C()
print(c.method_a())  # 输出: Method A
print(c.method_b())  # 输出: Method B

在这个例子中，C类同时继承了A类和B类，因此C类的实例可以调用A类和B类的方法。

2. 多态¶

2.1 什么是多态？¶

多态是指同一个方法在不同的类中可以有不同实现。多态性允许我们编写更通用的代码，这些代码可以处理不同类型的对象，而不需要知道这些对象的具体类型。

2.2 多态的实现¶

在Python中，多态通常通过方法重写来实现。不同的子类可以重写父类的同一个方法，从而提供不同的行为。

class Bird(Animal):
    def speak(self):
        return f"{self.name} chirps."

class Fish(Animal):
    def speak(self):
        return f"{self.name} bubbles."

# 创建一个包含不同动物实例的列表
animals = [Dog("Buddy"), Cat("Whiskers"), Bird("Tweety"), Fish("Nemo")]

# 遍历列表并调用speak方法
for animal in animals:
    print(animal.speak())

输出结果：

Buddy makes a sound.
Whiskers meows.
Tweety chirps.
Nemo bubbles.

在这个例子中，Dog、Cat、Bird和Fish类都重写了Animal类的speak方法。当我们遍历animals列表并调用speak方法时，每个对象都会根据其类调用相应的speak方法。

2.3 鸭子类型¶

Python中的多态性还体现在“鸭子类型”上。鸭子类型是指，只要一个对象具有某个方法或属性，我们就可以像使用其他具有相同方法或属性的对象一样使用它，而不需要关心它的具体类型。

class Car:
    def drive(self):
        return "Car is driving."

class Boat:
    def drive(self):
        return "Boat is sailing."

def start_vehicle(vehicle):
    print(vehicle.drive())

# 创建Car和Boat的实例
car = Car()
boat = Boat()

# 调用start_vehicle函数
start_vehicle(car)   # 输出: Car is driving.
start_vehicle(boat)  # 输出: Boat is sailing.

在这个例子中，Car类和Boat类都有一个drive方法。start_vehicle函数可以接受任何具有drive方法的对象，并调用它的drive方法。

3. 练习题¶

3.1 简单练习¶

创建一个Shape类，包含一个area方法。然后创建Rectangle和Circle类，分别继承Shape类，并重写area方法以计算矩形和圆的面积。

3.2 中等练习¶

创建一个Person类，包含name和age属性，以及一个introduce方法。然后创建Student和Teacher类，分别继承Person类，并重写introduce方法以输出不同的自我介绍。

3.3 复杂练习¶

创建一个Vehicle类，包含start和stop方法。然后创建Car、Bike和Truck类，分别继承Vehicle类，并重写start和stop方法。最后，创建一个Garage类，包含一个park方法，该方法可以接受任何Vehicle对象，并调用它的start和stop方法。

4. 总结¶

继承：继承允许一个类继承另一个类的属性和方法，从而实现代码的复用。子类可以重写父类的方法，或者添加新的属性和方法。
多态：多态允许不同的类对同一个方法有不同的实现。通过方法重写和鸭子类型，Python实现了多态性。
多重继承：Python支持多重继承，即一个子类可以继承多个父类。
鸭子类型：Python中的多态性还体现在鸭子类型上，即只要一个对象具有某个方法或属性，我们就可以像使用其他具有相同方法或属性的对象一样使用它。

通过掌握继承和多态，你可以编写出更加模块化、可重用和易于维护的代码。