多态的使用 | 手把手教你入门Python之六十七

2022-09-23 08:03:10

本文来自于千锋教育在阿里云开发者社区学习中心上线课程《Python入门2020最新大课》，主讲人姜伟。

多态的使用

子类重写父类方法

继承的特点：如果一个类A继承自类B，由类A创建出来的实例对象都能直接使用类B里定义的方法。

1、子类的实现和父类的实现完全不一样，子类可以选择重写父类的方法。
2、子类在父类的基础上又有更多的实现

class Person(object):
    def __init__(self, name, age):
        self.name = name
        self.age = age

    def sleep(self):
        print(self.name + '正在睡觉')

class Student(Person):
    def __init__(self, name, age, school):
        # self.name = name
        # self.age = age
        # 子类在父类实现的基础上，又添加了自己新的功能
        # 调用父类方法的两种方式：
        # 1. 父类名.方法名(self, 参数列表)
        # Person.__init__(self, name, age)
        # 2. 使用super直接调用父类的方法，推荐使用
        super(Student, self).__init__(name, age)
        self.school = school

    def sleep(self):
        print(self.name + '正在课间休息时睡觉')
    def study(self):
        print(self.name + '正在学习')


# s = Student('jerry', 20)  # 调用了父类的 __init__ 方法
s = Student('jerry', 20, '春天花花幼稚园')
# s.sleep()   # jerry正在睡觉  调用了父类的 sleep 方法
print(Student.__mro__)  # method resolution order
s.sleep()  # jerry正在课间休息时睡觉

p = Person('jack', 21)
p.sleep()  # jack正在睡觉

不使用多态的问题

⾯向对象的三⼤特性：

封装：这是定义类的准则，根据对象的特点，将⾏为和属性抽象出来，封装到⼀个类中。
继承：这是设计类的技巧。⽗类与⼦类，主要体现在代码的重⽤，不需要⼤量的编写重复代码。
多态：不同的⼦类调⽤相同的⽗类⽅法，产⽣不同的执⾏结果，可以增加代码的外部灵活度。多态是以继承和重写⽗类⽅法为前提的，它是⼀种调⽤⽅法的技巧，不会影响到类的内部设计。

多态是基于继承，通过子类重写父类的方法，达到不同的子类对象调用相同的父类方法，得到不同的结果。
作用是提高代码的灵活度。

场景

提供三个类：缉毒⽝、军⽝、⼈
缉毒⽝-->追查毒品，军⽝-->攻击假⼈，⼈-->让⼩狗⼲活
设计类来完成功能。

代码实现：

class ArmyDog(object):

    def bite_enemy(self):
        print('追击敌⼈')

class DrugDog(object):
    def track_drug(self):
        print('追查毒品')

class Person(object):

    def work_with_army(self, dog):
        dog.bite_enemy()

    def work_with_drug(self, dog):
        dog.track_drug()

ad = ArmyDog()
dd = DrugDog()

p = Person()
p.work_with_army(ad)
p.work_with_drug(dd)

思考：这段代码设是否有问题？
新增需求：此时，⼜多了⼀个⽝种，就⼜需要在Person类⾥新建⼀个⽅法，让这个⽅法操作新的狗。

class XiaoTianDog(object):

    def eat_moon(self):
        print('哮天⽝把⽉亮吃了')

class Person(object):

    def work_with_xiaotian(self, dog): # 添加⽅法
        dog.eat_moon()

Person 类总是不断的添加新的功能，每次都需要改动Person类的源码，程序的扩展性太差了！

最好是提供⼀个⽗类 Dog，具备 work 的功能，其他⼩狗继承它，这样只要是⼩狗类，则⾏为被统⼀起来了，我们⼈类完全可以保证，只要是⼩狗的⼦类，找它⼲活肯定不会有问题。
这样⼈只要⼀个⽅法就能逗任意种类的狗玩，哪怕是添加新的狗，⼈的类都不需要修改。
图示如下：

代码实现：

class Dog(object):

    def work(self): # ⽗类提供统⼀的⽅法，哪怕是空⽅法
        pass

class ArmyDog(Dog): # 继承 Dog

    def work(self): # ⼦类重写⽅法，并且处理⾃⼰的⾏为
        print('追击敌⼈')

class DrugDog(Dog):

    def work(self):
        print('追查毒品')

class Person(object):

    def work_with_dog(self, dog):
        dog.work() # 使⽤⼩狗可以根据对象的不同⽽产⽣不同的运⾏效果, 保障了代码的稳定性


# ⼦类对象可以当作⽗类来使⽤
dog = Dog()
ad = ArmyDog()
dd = DrugDog()


p = Person()
p.work_with_dog(dog)
p.work_with_dog(ad) # 同⼀个⽅法，只要是 Dog 的⼦类就可以传递，提供了代码的灵活性
p.work_with_dog(dd) # 并且传递不同对象，最终 work_with_dog 产⽣了不同的执⾏效果

最终效果
- Person 类中只需要调⽤ Dog 对象 work() ⽅法，⽽不关⼼具体是什么狗
- work() ⽅法是在 Dog ⽗类中定义的，⼦类重写并处理不同⽅式的实现
- 在程序执⾏时，传⼊不同的 Dog 对象作为实参，就会产⽣不同的执⾏效果

多态总结

定义：多态是⼀种使⽤对象的⽅式，⼦类重写⽗类⽅法，调⽤不同⼦类对象的相同⽗类⽅法，可以产⽣不同的执⾏结果
好处：调⽤灵活，有了多态，更容易编写出通⽤的代码，做出通⽤的编程，以适应需求的不断变化！
实现步骤：
- 定义⽗类，并提供公共⽅法
- 定义⼦类，并重写⽗类⽅法
- 传递⼦类对象给调⽤者，可以看到不同⼦类执⾏效果不同

码农公寓

多态的使用 | 手把手教你入门Python之六十七

多态的使用

子类重写父类方法

不使用多态的问题

场景

多态总结

配套视频

码农公寓

多态的使用

子类重写父类方法

不使用多态的问题

场景

多态总结

配套视频

相关文章