Python 面向对象之多态和鸭子类型

【一】多态

【1】概念

多态是面向对象的三大特征之一
多态：允许不同的对象对同一操作做出不同的反应
多态可以提高代码的灵活性，可扩展性，简化代码逻辑

【2】代码解释

在植物大战僵尸中，有寒冰射手，有双发射手还有火焰豌豆射手
他们都可以发射豌豆，源于豌豆射手这个类，就算没有发射豌豆的方法也可以继承父类的

class PeaShooter:
	def shoot(self):
        pass

class IcePeaShooter:
    def shoot(self):
        print("发射一颗寒冰豌豆")
class FirePeaShooter:
    def shoot(self):
        print("发射一颗火焰豌豆")
class DoublePeaShooter:
    def shoot(self):
        print("发射两颗普通豌豆")


# 实例化得到三个对象
ice_shooter = IcePeaShooter()
fire_shooter = FirePeaShooter()
double_shooter = DoublePeaShooter()
# 分别可以调用自己的shoot方法，互不干扰
ice_shooter.shoot()  # 发射一颗寒冰豌豆
fire_shooter.shoot()  # 发射一颗火焰豌豆
double_shooter.shoot()  # 发射两颗普通豌豆

【二】多态性

多态的重要性质

【1】运行时多态性（动态多态性）

也称为方法（函数）重写
在运行时，根据对象的实际类型来确定调用哪个方法
主要发生在同一层次的类之前
在上面的代码中，可以直接提供统一的接口来使用

# 定义统一的接口
def shoot(obj):
    obj.shoot()

# 实例化得到三个对象
ice_shooter = IcePeaShooter()
fire_shooter = FirePeaShooter()
double_shooter = DoublePeaShooter()

# 通过接口输入不同的对象，调用相同的方法触发不同的结果
shoot(ice_shooter)  # 发射一颗寒冰豌豆
shoot(fire_shooter)  # 发射一颗火焰豌豆
shoot(double_shooter)  # 发射两颗普通豌豆

【2】编译时多态性（静态多态性）

也称为方法（函数）重载
在编译阶段，根据方法的参数类型、个数或顺序来决定调用哪个方法
主要发生在同一个类中的同名方法之间

class FirePeaShooter:
    def shoot(self):
        print("发射了一颗火焰豌豆")

    def shoot(self, name):
        print(f"发向{name}射了一颗火焰豌豆")

    def shoot(self, zombie, num):
        print(f"向{zombie}发射了{num}颗火焰豌豆")


# 实例化对象
fire_shooter = FirePeaShooter()
# 根据个数判断调用的方法
# fire_shooter.shoot()
# fire_shooter.shoot("普通僵尸")
fire_shooter.shoot("普通僵尸", "2")

在python中并没有静态方法重载，可以通过可变长关键字参数实现
在python中并没有静态方法重载，可以通过可变长关键字参数实现
在python中并没有静态方法重载，可以通过可变长关键字参数实现

class FirePeaShooter:

    def shoot(self, *args):

        if len(args) == 2:
            a = f"向{args[0]}"
            b = f"{args[-1]}颗"
        elif len(args) == 1:
            a = f"向{args[0]}"
            b = ""
        else:
            a = b = ""
        print(f"{a}发射了{b}火焰豌豆")


# 实例化对象
fire_shooter = FirePeaShooter()
# 根据个数判断调用的方法
fire_shooter.shoot()
fire_shooter.shoot("普通僵尸")
fire_shooter.shoot("普通僵尸", "2")
# 发射了颗火焰豌豆
# 向普通僵尸发射了颗火焰豌豆
# 向普通僵尸发射了2颗颗火焰豌豆

【三】鸭子类型

鸭子类型是一种编程风格，决定一个对象是否有正确的接口
鸭子类型的核心思想：如果他走起来像鸭子，叫起来像鸭子，那么他就可以被视为鸭子
可以完全不依赖于继承，只要具备相同的属性和方法，同样可以实现不考虑对象类型而使用对象
比起继承，鸭子类型在某种程度上是实现了程序的松耦合度

class IcePeaShooter:
    def shoot(self):
        print("发射一颗寒冰豌豆")
class FirePeaShooter:
    def shoot(self):
        print("发射一颗火焰豌豆")
class DoublePeaShooter:
    def shoot(self):
        print("发射两颗普通豌豆")


# 实例化得到三个对象
ice_shooter = IcePeaShooter()
fire_shooter = FirePeaShooter()
double_shooter = DoublePeaShooter()
# 不依赖于继承，只要有相同的方法名
ice_shooter.shoot()  # 发射一颗寒冰豌豆
fire_shooter.shoot()  # 发射一颗火焰豌豆
double_shooter.shoot()  # 发射两颗普通豌豆