面向对象的三大特性之二：多态、多态性

一 多态

多态指的是一类事物有多种形态。

多态的概念指出了对象如何通过他们的共同属性和动作来操作及访问，而不需要考虑他们具体的类

多态表明了动态（又名运行时）绑定的存在，允许重载及运行时类型确定和验证。

注意：一是python中一切皆对象，二是不同对象可以调用相同方法，你不用考虑它是由什么类来的。

例1：水是一个类。不同温度，水被实例化成了不同的状态：冰、水蒸气、雾。很多人误以为这就已经是多态，而多态实质是“运行时绑定的存在”

　　多态体现于由一个类实例化出的多个对象，这些对象执行的相同方法时，执行的过程和结果是不一样的。

　　冰、水蒸气、雾有一个共同的方法：变成云，但是  冰变云()  水蒸气变云()   是截然不同的两个过程，虽然调用相同的方法。

#_*_coding:utf-8_*_
__author__ = 'Linhaifeng'
class H2O:
    def __init__(self,name,temperature):
        self.name=name
        self.temperature=temperature
    def turn_ice(self):
        if self.temperature < 0:
            print('[%s]温度太低结冰了' %self.name)
        elif self.temperature > 0 and self.temperature < 100:
            print('[%s]液化成水' %self.name)
        elif self.temperature > 100:
            print('[%s]温度太高变成了水蒸气' %self.name)
    def aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaa(self):
        pass

class Water(H2O):
    pass
class Ice(H2O):
    pass
class Steam(H2O):
    pass

w1=Water('水',25)
i1=Ice('冰',-20)
s1=Steam('蒸汽',3000)

w1.turn_ice()
i1.turn_ice()
s1.turn_ice()
# 三个对象分别所属的类继承了同一个父类，因此绑定了同样的父类中的方法
# 三种对象调用相同的函数方法，得到了三个不同的结果
# 将上述三步统一成一个函数接口，用func来直接调用
def func(obj):
    obj.turn_ice()

func(w1)  #---->w1.turn_ice()
func(i1)  #---->i1.turn_ice()
func(s1)

例2：动物有多种形态：人，狗，猪

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

文件有多种形态：文本文件，可执行文件

import abc
class File(metaclass=abc.ABCMeta): #同一类事物:文件
    @abc.abstractmethod
    def click(self):
        pass

class Text(File): #文件的形态之一:文本文件
    def click(self):
        print('open file')

class ExeFile(File): #文件的形态之二:可执行文件
    def click(self):
        print('execute file')

二 多态性

一 什么是多态动态绑定（在继承的背景下使用时，有时也称为多态性）

多态性是指在不考虑实例类型的情况下使用实例

在面向对象方法中一般是这样表述多态性：
向不同的对象发送同一条消息（！！！obj.func():是调用了obj的方法func，又称为向obj发送了一条消息func），不同的对象在接收时会产生不同的行为（即方法）。
也就是说，每个对象可以用自己的方式去响应共同的消息。所谓消息，就是调用函数，不同的行为就是指不同的实现，即执行不同的函数。

比如：老师.下课铃响了（），学生.下课铃响了()，老师执行的是下班操作，学生执行的是放学操作，虽然二者消息一样，但是执行的效果不同

多态性分为静态多态性和动态多态性

　　静态多态性：如任何类型都可以用运算符+进行运算

　　动态多态性：如下

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法
#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,我们可以定义一个统一的接口来使用
def func(obj):
    obj.talk()

二 为什么要用多态性（多态性的好处）

其实大家从上面多态性的例子可以看出，我们并没有增加什么新的知识，也就是说python本身就是支持多态性的，这么做的好处是什么呢？

1.增加了程序的灵活性

　　以不变应万变，不论对象千变万化，使用者都是同一种形式去调用，如func(animal)

2.增加了程序额可扩展性

　　通过继承animal类创建了一个新的类，使用者无需更改自己的代码，还是用func(animal)去调用 　　　　

>>> class Cat(Animal): #属于动物的另外一种形态：猫
...     def talk(self):
...         print('say miao')
... 
>>> def func(animal): #对于使用者来说，自己的代码根本无需改动
...     animal.talk()
... 
>>> cat1=Cat() #实例出一只猫
>>> func(cat1) #甚至连调用方式也无需改变，就能调用猫的talk功能
say miao

'''
这样我们新增了一个形态Cat，由Cat类产生的实例cat1，使用者可以在完全不需要修改自己代码的情况下。使用和人、狗、猪一样的方式调用cat1的talk方法，即func(cat1)
'''

注意：

多态实际上是依赖于继承的两种含义的：“改变”和“扩展”本身就意味着必须有机制去自动选用你改变/扩展过的版本，故无多态，这两种含义无法实现。

因此，多态实质上是继承的实现细节，所以说让多态和封装、继承这俩概念并列，有点不符合逻辑。

多态一定是在执行过程中才体现出来的，要实现不同子类产生对象调用相同父类方法必须先继承产生同一父类的子类。

因此多态和继承是不能拆分开的。

三  鸭子类型

逗比时刻：

　　Python崇尚鸭子类型，即‘如果看起来像、叫声像而且走起路来像鸭子，么它就是鸭子’

python程序员通常根据这种行为来编写程序。例如，如果想编写现有对象的自定义版本，可以继承该对象

也可以创建一个外观和行为像，但与它无任何关系的全新对象，后者通常用于保存程序组件的松耦合度。

例1：利用标准库中定义的各种‘与文件类似’的对象，尽管这些对象的工作方式像文件，但他们没有继承内置文件对象的方法

#二者都像鸭子,二者看起来都像文件,因而就可以当文件一样去用
class TxtFile:
    def read(self):
        pass

    def write(self):
        pass

class DiskFile:
    def read(self):
        pass
    def write(self):
        pass

例2：其实大家一直在享受着多态性带来的好处，比如Python的序列类型有多种形态：字符串，列表，元组，多态性体现如下

#str,list,tuple都是序列类型
s=str('hello')     #工厂函数：面向对象的类，能产生一个个对象的函数。看起来像一个函数，利用它可以产生一个字符串对象
l=list([1,2,3])
t=tuple((4,5,6))

#我们可以在不考虑三者类型的前提下使用s,l,t
#len(str1)本质上就是来调用对象str1下的_len_方法
s.__len__()　　　　#等价于len(s)
l.__len__() 　　　 #等价于len(l)
t.__len__()       #等价于len(t)