Python面向对象编程之继承与多态详解

1. 继承

继承是面向对象编程中的一个重要概念，它允许子类继承父类的属性和方法。在 Python 中，我们可以通过以下方式来实现继承：

class Person:
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def introduce(self):
        print(f"Hello, my name is {self.name} and I'm {self.age} years old.")

class Student(Person):
    def __init__(self, name, age, school):
        super().__init__(name, age)
        self.school = school

    def introduce(self):
        super().introduce()
        print(f"I'm a student of {self.school}.")

在上面的代码中，我们定义了一个父类 Person 和一个子类 Student。子类通过在类定义中将父类作为参数来继承父类，即：

class Student(Person):
    ...

在子类中，我们可以使用 super() 函数来调用父类的方法。在上面的代码中，我们通过 super().__init__(name, age) 的方式调用了父类的 __init__() 方法。另外，在子类中我们也可以重写父类的方法，这样就可以对父类方法进行扩展或修改。在上面的代码中，我们重写了父类的 introduce() 方法，同时调用了父类的 introduce() 方法。

2. 多态

多态是面向对象编程中的另一个重要概念，它允许不同类的对象使用相同的方法名称，但是具体执行的方法实现不同。在 Python 中，我们可以通过以下方式来实现多态：

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Bark")

class Cat(Animal):
    def make_sound(self):
        print("Meow")

在上面的代码中，我们定义了一个父类 Animal 和两个子类 Dog 和 Cat。它们都继承了 Animal 父类，并且都重写了父类的 make_sound() 方法。在使用过程中，我们可以根据具体的对象类型来调用相应的方法：

animals = [Dog(), Cat()]

for animal in animals:
    animal.make_sound()  # 根据具体的对象类型调用相应的方法

在上面的代码中，我们将两个不同的动物对象 Dog() 和 Cat() 放在了列表 animals 中，并且通过 for in 循环遍历列表中的每个元素。在循环过程中，我们根据具体的对象类型来调用相应的 make_sound() 方法。在输出结果中，我们可以看到，针对不同的对象类型，执行的方法实现是不同的，这就是多态的体现。

3. 示例说明

示例一

假设我们现在有一个父类 Vehicle 和两个子类 Car 和 Bus，其中 Car 和 Bus 都继承了 Vehicle 父类，并且都重写了父类的 run() 方法。在 Car 子类中，我们还新增了一个 fly() 方法。下面是示例代码：

class Vehicle:
    def run(self):
        pass

class Car(Vehicle):
    def run(self):
        print("Car is running")

    def fly(self):
        print("Car is flying")

class Bus(Vehicle):
    def run(self):
        print("Bus is running")

如果我们现在需要编写一个函数，这个函数接受一个 Vehicle 类型的参数，并且调用这个参数的 run() 方法，我们该如何实现呢？

def test_vehicle(v: Vehicle):
    v.run()

上面这段代码就是一个示例。我们定义了一个函数 test_vehicle，这个函数接受一个类型为 Vehicle 的参数，并且调用参数的 run() 方法。

下面是测试代码：

car = Car()
bus = Bus()
vehicles = [car, bus]

for vehicle in vehicles:
    test_vehicle(vehicle)

在上面的代码中，我们创建了一个 Car 类的对象 car，一个 Bus 类的对象 bus，并且将它们放在一个列表 vehicles 中。然后我们通过 for in 循环遍历每个元素，并且将其作为参数传递给 test_vehicle() 函数进行测试。

输出结果如下：

Car is running
Bus is running

我们可以看到，在 test_vehicle 函数中，我们只调用了 Vehicle 类的 run() 方法，而具体执行的方法却是 Car 类和 Bus 类中的重写方法，这就是多态的体现。

示例二

假设我们现在有一个父类 Animal 和两个子类 Dog 和 Cat，它们都继承了 Animal 父类，并且都重写了父类的 make_sound() 方法。下面是示例代码：

class Animal:
    def make_sound(self):
        pass

class Dog(Animal):
    def make_sound(self):
        print("Bark")

class Cat(Animal):
    def make_sound(self):
        print("Meow")

如果我们想让代码更加灵活，支持更多的动物种类。我们可以新增一个子类 Sheep，重写 make_sound() 方法。下面是示例代码：

class Sheep(Animal):
    def make_sound(self):
        print("Baa")

然后我们可以在测试代码中，向 animals 列表中新增一个 Sheep 实例对象，并且调用 test_animal() 函数进行测试。

dog = Dog()
cat = Cat()
sheep = Sheep()
animals = [dog, cat, sheep]

for animal in animals:
    test_animal(animal)

输出结果如下：

Bark
Meow
Baa

我们可以看到，新增一个子类 Sheep 并没有影响原有的代码，同时它也可以正常的使用多态。这就是面向对象编程中的继承与多态。