Python面向对象——多态

目录

多态性的实现方式

1. 方法重写（Method Overriding）

2. 使用基类类型的引用

多态性的应用

示例：图形绘制

多态性与鸭子类型

关键点

总结

---

在面向对象编程中，多态性（Polymorphism）是指相同的操作可以作用于不同的对象，并且可以根据对象的类型表现出不同的行为。多态性使得程序具有更好的扩展性和灵活性。

在 Python 中，多态性的实现主要依赖于继承和方法重写。具体来说，多态性允许使用基类类型的引用来引用子类对象，并且在运行时调用子类的重写方法。

多态性的实现方式

1. 方法重写（Method Overriding）

在继承中，子类可以重写父类的方法。这是实现多态性的基础。

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

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

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

# 创建对象
dog = Dog()
cat = Cat()

# 调用方法
print(dog.speak())  # 输出: Woof!
print(cat.speak())  # 输出: Meow!

在这个例子中，Dog 和 Cat 类都重写了 Animal 类的 speak 方法。当调用 speak 方法时，具体的实现由具体的对象决定。

2. 使用基类类型的引用

多态性使得可以用基类类型的引用来引用子类对象，并且在运行时调用子类的重写方法。

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

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

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

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

# 创建对象
dog = Dog()
cat = Cat()

# 使用基类类型的引用
animal_speak(dog)  # 输出: Woof!
animal_speak(cat)  # 输出: Meow!

在这个例子中，animal_speak 函数接受一个 Animal 类型的参数，但在运行时，可以传入任何 Animal 的子类对象，并且会调用相应子类的 speak 方法。

多态性的应用

多态性在实际应用中非常有用，特别是在需要处理一组具有不同具体实现的对象时。

示例：图形绘制

假设我们有一个图形绘制程序，支持绘制不同类型的图形（如圆形、矩形）。可以使用多态性来实现这个需求。

class Shape:
    def draw(self):
        raise NotImplementedError("Subclass must implement abstract method")

class Circle(Shape):
    def draw(self):
        return "Drawing a Circle"

class Rectangle(Shape):
    def draw(self):
        return "Drawing a Rectangle"

# 定义一个绘图函数
def draw_shape(shape: Shape):
    print(shape.draw())

# 创建对象
circle = Circle()
rectangle = Rectangle()

# 使用多态性
draw_shape(circle)      # 输出: Drawing a Circle
draw_shape(rectangle)   # 输出: Drawing a Rectangle

在这个例子中，不同的图形类（如 Circle 和 Rectangle）都实现了 Shape 类的 draw 方法。使用多态性，可以通过 Shape 类型的引用来调用具体图形对象的 draw 方法。

多态性与鸭子类型

Python 是一种动态类型语言，除了通过继承实现多态性外，还可以通过鸭子类型（Duck Typing）实现多态性。鸭子类型是一种动态类型系统，在这种系统中，一个对象是否能使用取决于它是否具有所需的方法或属性，而不是它的实际类型。

在 Python 中，鸭子类型（Duck Typing）的概念来自一句谚语：“如果它走路像鸭子，叫声像鸭子，那么它就是一只鸭子。”也就是说，一个对象的类型和方法是否可以用并不取决于这个对象的实际类型，而是它是否具有某个方法或属性。

在传统的静态类型语言中，一个函数的参数类型通常是固定的，这种类型检查是在编译时进行的。而在 Python 这样的动态类型语言中，类型检查是在运行时进行的。因此，只要传入的对象具有所需的方法或属性，Python 就会认为它是合适的类型。

class Bird:
    def fly(self):
        return "Bird is flying"

class Airplane:
    def fly(self):
        return "Airplane is flying"

def let_it_fly(obj):
    print(obj.fly())

# 创建对象
bird = Bird()
airplane = Airplane()

# 使用鸭子类型实现多态性
let_it_fly(bird)       # 输出: Bird is flying
let_it_fly(airplane)   # 输出: Airplane is flying

在这个例子中，let_it_fly 函数不关心传入对象的类型，只要对象具有 fly 方法即可。

关键点

1. 动态类型检查：

   • let_it_fly 函数不会在调用时检查 obj 的实际类型。
   • 只要 obj 具有 fly 方法，Python 就会调用它，而不关心 obj 是哪种类型的实例。

2. 适配不同对象：

   • 在例子中，Bird 类和 Airplane 类都有 fly 方法。
   • 当我们传递 bird（Bird 类的实例）或 airplane（Airplane 类的实例）给 let_it_fly 函数时，Python 会调用各自的 fly 方法，输出不同的结果。

3. 灵活性：

   • 这种方式使得函数可以适配更多类型的对象，只要这些对象具有所需的方法或属性，而不必严格继承自某个特定的类。

总结

• 多态性 使得相同的操作可以作用于不同的对象，并根据对象的类型表现出不同的行为。
• 方法重写 是实现多态性的基础，子类可以重写父类的方法。
• 可以使用基类类型的引用来引用子类对象，并在运行时调用子类的重写方法。
• 在 Python 中，除了通过继承实现多态性外，还可以通过鸭子类型实现多态性。