社区首页 >专栏 >多态

多态

原创

Heaven645

发布于 2024-08-07 11:24:14

12600

代码可运行

文章被收录于专栏：Python学习Python学习

运行总次数：0

代码可运行

前言

多态（Polymorphism）是面向对象编程中的核心概念，本章将详细讲解 Python 中多态的实现方式以及如何应用多态提高代码的可维护性。

本篇文章参考：黑马程序员

一、基本概念

定义：

多态是指同一个行为通过不同的对象获得不同的结果或状态。

类型：

①鸭子类型（Duck Typing）

在 Python 中，我们不关注对象的具体类型，只关注对象是否具有某个方法或属性。如果一个对象能“像鸭子一样叫，像鸭子一样走”，那么即使它不是一个鸭子，Python 也能通过该对象执行操作。

class Bird:  
    def fly(self):  
        return "I can fly!"  

class Airplane:  
    def fly(self):  
        return "I am an airplane!"  

class Fish:  
    def swim(self):  
        return "I can swim!"  

def lets_fly(thing):  
    print(thing.fly())  

# 使用鸭子类型  
bird = Bird()  
airplane = Airplane()  

lets_fly(bird)      # 输出: I can fly!  
lets_fly(airplane)  # 输出: I am an airplane!  
# lets_fly(Fish())  # 会出错，因为 Fish 类没有 fly 方法

输出结果：
I can fly!
I am an airplane!

【分析】

lets_fly() 函数期望传入一个具有 fly() 方法的对象。Bird 和 Airplane 类都实现了 fly() 方法，因此它们可以作为参数传递给 lets_fly()。由于Fish 没有 fly() 方法，如果 Fish 被传入，程序运行后会报错。

②方法重写（Method Overriding）

子类可重写父类的方法，以实现不同的功能。当通过父类调用这个方法时，会调用子类的实现。

思考：那我们前两章讲到的继承的复写和多态的方法重写有什么区别呢？

答：在 Python 中，继承中的复写（通常指方法重写）和多态中的方法重写实际上是同一个概念，都是指在子类中重写父类的方法，但其上下文和侧重点有所不同。

在继承关系中，子类重写父类的方法，目的是给该方法提供不同的实现，以满足子类的特定需求。这是一种语言级别的概念，侧重于代码的结构和重用。

而多态中的"方法重写"更广泛地应用于设计模式，它关注的是运行时的行为选择，强调的是基于接口而不是固定实现，允许根据实际使用的对象类型动态地调用相应的方法。

class Animal:
    def speak(self):
        pass

class Dog(Animal):
    def speak(self):
        print("汪汪汪")

class Cat(Animal):
    def speak(self):
        print("喵喵喵")

def make_noise(animal: Animal):
    # 制造噪音，需要传入Animal对象
    animal.speak()

# 使用两个子类对象调用函数
dog = Dog()
cat = Cat()

make_noise(dog)
make_noise(cat)

输出结果：
汪汪汪
喵喵喵

【分析】

父类 Animal 定义了一个方法 speak()，而子类 Dog 和 Cat 重写了该方法，提供各自特定的实现。函数 make_noise() 接受一个 Animal 类型的参数，它可以接受任何 Animal 的子类实例（如 Dog 或 Cat）。这是因为子类是父类的特例，Dog 和 Cat 类是对 Animal 的扩展，因此任何 Dog 或 Cat 的实例都可以被视为 Animal 的实例。

多态常用于继承关系中，允许以父类进行定义和声明，而以子类实现具体功能，从而实现相同的行为但具有不同的状态。

例如，当一个函数的参数声明为父类对象时，实际上可以传入其子类的对象来执行相应的操作，这使得我们能够通过统一的接口来处理不同类型的对象，从而实现灵活的代码设计。

异同点：

特征	鸭子类型	方法重写
定义	一种类型的特性通过行为来判断，而不是类型本身	在子类中重写父类的方法以提供不同的实现
实现方式	只需实现所需的方法	明确使用继承结构，子类根据需要重写父类方法
灵活性	高（适用于任何对象只要实现了必要的方法）	略低（依赖于类的继承关系）
关注点	强调对象行为而非类型	强调屏蔽父类的具体实现，提供自定义实现
使用场景	适合处理不同类型的对象，只要它们实现了同样的方法	适合在继承关系中有明确父子类关系的场景

二、抽象类

抽象类：包含抽象方法的类。

抽象方法：没有具体实现的方法

这种设计的意义在于父类定义了应包含的方法，而具体的实现则由子类负责决定。

例如，空调可以制冷、制热和左右扫风。我们将这三个功能制定为空调制造的标准，不同的厂家必须根据这个标准各自实现功能。抽象类可以看作是这种标准，它包含了一些抽象方法，要求子类必须实现这些方法。

这种设计的作用主要体现在以下几个方面：

顶层设计：抽象类提供了一个设计标准，以便子类进行具体实。
软性约束：抽象类对子类施加了一种约束，要求子类必须重写（实现）父类的一些方法。
配合多态：通过多态的机制，我们可以获得不同的工作状态。

# 抽象类
class AC:
    # 制冷
    def cool_wind(self):
        pass

    # 制热
    def hot_wind(self):
        pass

    # 左右摆风
    def swing_l_r(self):
        pass


class Midea_AC(AC):
    def cool_wind(self):
        print("美的空调制冷")

    def hot_wind(self):
        print("美的空调制热")

    def swing_l_r(self):
        print("美的空调左右摆风")

class GREE_AC(AC):
    def cool_wind(self):
        print("格力空调制冷")

    def hot_wind(self):
        print("格力空调制热")

    def swing_l_r(self):
        print("格力空调左右摆风")

def make_cool(ac: AC):
    ac.cool_wind()

midea_ac = Midea_AC()
gree_ac = GREE_AC()

make_cool(midea_ac)
make_cool(gree_ac)