多态

在面向对象中，父类、子类通过继承联系在一起，如果可以通过一套方法，就可以实现不同表现，就是多态。

在Python中，多态是面向对象编程中的一个重要概念，它允许不同类型的对象对相同的方法名做出不同的响应。多态性使得代码更加灵活，可以在不同的情境下使用相同的接口来调用不同的方法。

Python实现多态的方式主要是通过方法的重写（覆盖）。当子类继承自父类并重写了父类的方法时，可以根据对象的类型来调用相应的方法。

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

## 定义一个父类
class Shape:
    def area(self):
        pass

## 定义一个子类，继承自Shape类
class Rectangle(Shape):
    def __init__(self, width, height):
        self.width = width
        self.height = height
    
    def area(self):
        return self.width * self.height

## 定义另一个子类，继承自Shape类
class Circle(Shape):
    def __init__(self, radius):
        self.radius = radius
    
    def area(self):
        import math
        return math.pi * self.radius ** 2

## 使用多态调用方法
shapes = [Rectangle(4, 5), Circle(3)]

for shape in shapes:
    print("Area:", shape.area())

在这个示例中，我们定义了一个名为Shape的父类，它包含一个名为area()的方法。然后，我们定义了两个子类Rectangle和Circle，它们分别重写了父类的area()方法以计算矩形和圆的面积。最后，我们创建了一个包含不同类型对象的列表，并使用多态性调用它们的area()方法。

通过多态，我们可以编写更加通用的代码，不需要关心对象的具体类型，只需要调用统一的接口即可。这样可以提高代码的可读性和可维护性，并且使得程序更加灵活和易于扩展。

示例

class Animal():
    def __init__(self, name):
        self.name = name
    def shout(self):
        print('Animal shouts')

class Cat(Animal):
    def __init__(self, name, age):
        super().__init__(name)
        self.age = age
    def shout(self):
        print('Cat shouts')

class Dog(Animal):
    def shout(self):
        print('Dog shouts')

d = Dog('wangcai')
d.shout() # Dog shouts

c = Cat('hauhua', 3)
c.shout() # Cat shouts

以上代码展示了多态的概念。

多态是面向对象编程中的一个重要特性，它允许不同类的对象对相同的消息做出不同的响应。在这段代码中，Animal 类有一个 shout() 方法，而 Cat 类和 Dog 类都继承自 Animal 类，并且它们都定义了自己的 shout() 方法。

当你调用 shout() 方法时，具体执行的是对象的类型决定的。对于 d 对象，它是 Dog 类的实例，因此调用 d.shout() 时执行的是 Dog 类中定义的 shout() 方法，输出 “Dog shouts”。对于 c 对象，它是 Cat 类的实例，因此调用 c.shout() 时执行的是 Cat 类中定义的 shout() 方法，输出 “Cat shouts”。

这种根据对象类型执行不同行为的特性就是多态的体现。因此，以上代码确实展示了多态的概念。

实现多态的两要素

继承：多态需要至少两个类，其中一个类是父类（基类），另一个是子类（派生类）。子类继承自父类，继承可以使子类获得父类的属性和方法，并且可以根据需要扩展或修改这些属性和方法。
方法覆盖：子类可以重写（覆盖）父类中的方法。这意味着子类可以定义与父类中同名的方法，并且根据需要重新实现这些方法。当子类中定义了与父类相同名称的方法时，子类对象调用该方法时将执行子类中的方法，而不是父类中的方法。这样可以根据对象的实际类型来决定执行哪个方法，实现多态的效果。

其他方面：

调用时机：多态的体现是在运行时确定的，而不是在编译时。即使在编写代码时并不知道对象的具体类型，但在程序运行时根据对象的实际类型来决定执行哪个方法。
统一接口：多态通过为不同类的对象提供统一的接口来实现。这意味着不同的子类可以实现相同的方法，从而使得它们可以被同样的方式调用，提高了代码的灵活性和可扩展性。