Python之多态

在 Python 中，多态是通过动态绑定实现的。这意味着，在运行时，Python 解释器会根据对象的类型来确定应该调用哪个方法或函数。这使得 Python 代码更加灵活和可重用。

下面是一个简单的例子，演示了 Python 中的多态：

class Animal:
    def speak(self):
        raise NotImplementedError("Subclass must implement this method")

class Dog(Animal):
    def speak(self):
        return "Woof!"

class Cat(Animal):
    def speak(self):
        return "Meow!"

def animal_speak(animal):
    print(animal.speak())

dog = Dog()
cat = Cat()

animal_speak(dog)  # 输出 "Woof!"
animal_speak(cat)  # 输出 "Meow!"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20

在这个例子中，我们定义了一个 Animal 类和一个 Dog 类和一个 Cat 类。Animal 类有一个 speak() 方法，它是一个抽象方法，需要在子类中实现。Dog 类和 Cat 类继承自 Animal 类，并实现了 speak() 方法。然后我们定义了一个函数 animal_speak()，它接受一个 Animal 类型的参数，并调用它的 speak() 方法。这个函数可以接受不同类型的参数（比如 Dog 或 Cat），因为它们都继承自 Animal 类，并实现了 speak() 方法。这就是多态的概念。

Python中的多态是指同一个方法或函数可以应用于不同的对象类型，并且可以根据对象类型的不同表现出不同的行为。多态的实现依赖于Python的动态类型系统，可以在运行时根据对象的类型来决定执行什么样的代码。

在Python中，多态是通过继承和重写基类的方法或函数来实现的。子类可以根据自己的需求重写基类的方法或函数，这样在调用这些方法或函数时，就会根据对象的类型来执行相应的方法或函数。

下面是一个简单的例子，演示了如何在Python中实现多态：

class Shape:
    def draw(self):
        pass

class Circle(Shape):
    def draw(self):
        print("Drawing circle")

class Square(Shape):
    def draw(self):
        print("Drawing square")

def draw_shape(shape):
    shape.draw()

# 创建 Circle 和 Square 对象
circle = Circle()
square = Square()

# 调用 draw_shape 函数，传入 Circle 和 Square 对象
draw_shape(circle)  # 输出 "Drawing circle"
draw_shape(square)  # 输出 "Drawing square"
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22

在上面的例子中，定义了一个基类 Shape 和两个子类 Circle 和 Square。Circle 和 Square 都继承了 Shape 类，并重写了 draw 方法。在 draw_shape 函数中，通过传入不同的对象类型来调用它们的 draw 方法，实现了多态。

《AUTOSAR谱系分解(ETAS工具链)》之总目录