python强势来袭-0027-面向对象必杀技~多态~

面向对象程序设计最主要的有三个特征：封装、继承、多态

本节内容主要讲解面向对象的第一个特征：多态

1 多态的意义

多态是让我们的程序在运行的过程中，在不同的状态下进行动态的切换，实现复杂的功能为目的的一种程序开发手段

在之前的章节中，实现了类型的继承关系之后，其实我们已经见过多态的一种操作了：方法重写实现的运行时多态，对象在执行具体的方法时，会直接执行父类中继承的对应的方法，如果该方法在子类中重写了，就会执行子类中重写过的方法，实现的是一种运行过程中的多态处理，代码如下：

# 定义父类
class Person(object):
    def __init__(self, name):
        self.__name = name
    def playing(self):
        print(self.__name + "正在游戏中...")
# 定义子类，继承自Person
class Man(Person):
    def __init__(self, name):
        Person.__init__(self, name)
# 定义子类，继承自Person
class Women(Person):
    def __init__(self, name):
        Person.__init__(self, name)
    def playing(self):
        print(self.name + "正在游戏封装找茬中...")
# 创建对象
man = Man("tom")
women = Women("jerry")

man.playing()    # 子类中没有重写，直接执行从父类继承的playing()函数
women.playing() #子类中重写了，直接执行子类中的playing()函数

2. 多态的扩展

我们定义一个这样的医疗系统，所有的男人、女人、小孩等等都可以去医院看病，然后康复的一个过程。

# 定义一个人的类型
class Person(object):
    def __init__(self, name, age, gender):
        self.__name = name
        self.__age = age
        self.gender = gender
    def health(self):
        print(self.__name + "康复了..")

# 定义医院的类型
class Hospital(object):
    # 定义一个治疗的方法，可以给人治病
    def care(self, person):
        print("正在治病")
        person.health()

# 定义男人类型，继承自Person类型
class Man(Person):
    def __init__(self, name, age):
        Person.__init__(self, name, age, "男")
    def health(self):
        print(self.__name + "~介个男人康复了..")
# 定义女人类型，继承自Person类型
class Women(Person):
    def __init__(self, name, age):
        Person.__init__(self, name, age, "男")
    def health(self):
        print(self.__name + "~介个男人康复了..")

# 创建人物对象
man = Man("小凡", 19)
women = Women("碧瑶",16)

# 创建医院对象
h = Hospital()

# 治病救人
h.care(man)    # 治疗Man类型的对象
h.care(women) # 治疗Women类型的对象

上面的代码中，我们已经可以看到，只要是从Person类型继承过来的类型所创建的对象，都可以在医院Hospital对象的care()中进行治疗。已经是一种多态。

同时如果功能需要扩展，需要多出来一个人物类型：小孩，小孩也会生病，也需要治疗~此时对于功能的扩展非常简洁，值需要添加如下代码就可以搞定：

# 创建一个小孩类型，继承自Person
class Children(Person):
    def __init__(self, name):
        Person.__init__(self, name)

# 创建具体的小孩对象
c = Children("小家伙")

h.care(c) # 执行结果~小家伙康复了

可以看到这里扩展一个功能变得非常的简单，对象和对象之间的协同关系由于继承多态的存在让功能的扩展实现起来比较快捷了。

2. 多态的完善

上面的代码中，我们其实是存在一定的缺陷的
上述代码设计的初衷是医院对象可以治病救人，也就是Hosiptal对象的care()函数可以治疗Person派生出来的对象。
但是从代码逻辑中，我们可以看到只要传递给care()函数的参数对象中包含health()函数就可以进行处理，而并非必须是Person对象。

此时需要在函数中进行判断处理，如果是Person对象就进行care()治疗的处理，如果不是Person对象，就提示不做治疗操作。

对象和类型的判断可以通过isinstance(obj, Type)进行类型的判断，如：

# 创建各种对象
lx = [1,2,3,4,5]
ld = {"1":"a", "2":"b"}
ls = {"1", "2", "3"}
man = Man("tom", 22)
women = Women("jerry", 21)

# isinstance(obj, Type)判断是否属于某种类型
isinstance(lx, list)  # 执行结果：True
isinstance(ld, dict)  # 执行结果：True
isinstance(ls, set)  # 执行结果：True
isinstance(man, Man)  # 执行结果：True
isinstance(women, Women)  # 执行结果：True
isinstance(man, Person)  # 执行结果：True
isinstance(women, Person)  # 执行结果：True
isinstance(women, list)  # 执行结果：False

上述代码中，我们可以观察到通过isinstance()函数进行变量所属数据类型的判断了，同时在继承关系中，有一个情理之中的判断结果：man是Man类型的，同时也是Person类型的，因为Man类型是从Person类型继承过来的。

所以可以对之前的Hospital的care()函数进行如下改造：

# 改造Hospital对象
class Hospital(object):
    # 改造care()函数进行处理
    def care(person):
        if isinstance(person, Person):
            print("正在治疗中...")
            person.health()
        else:
            print("不是合适的对象")

此时如果再传递参数，就要求必须是Person类型才可以进行治疗

# 定义一个Animal类型
class Animal :
    def __init__(self, name):
        self.__name = name
    def health(self):
        print(self.__name + "正在康复中...")
# 创建对象
a = Animal("shuke")
# 治疗
h.care(a)
# 执行结果：不是合适的对象

---