Day 25 多态.

　一、多态的概念

多态指的是一类事物有多种形态.
动物有多种形态：人，狗，猪

from abc import ABCMeta,abstractmethod
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')

　　

from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta): #规范
    @abstractmethod
    def pay(self,money):
        pass
        raise NotImplemented
class ApplePay(Payment):#
    def pay(self,money):pass
app = ApplePay()

#微信支付
class Wechatpay(Payment):
    def pay(self,money):
        print('通过微信支付了%s元钱'%(money))
#支付宝支付
class Alipay(Payment):
    def pay(self,money):
        print('通过支付宝支付了%s元钱'%(money))
# apple pay
class Apple(Payment):
    def pay(self,money):
        print('通过评估支付了%s'%(money))

wp =Wechatpay()
wp.pay(100)
alp =Alipay()
app =ApplePay()

def pay(pay_obj,money):#程序的归一化设计
    pay_obj.pay(money)

pay(alp,100)
pay(wp,100)
pay(app,100)
输出结果为

# 通过微信支付了100元钱
# 通过支付宝支付了100元钱
# 通过微信支付了100元钱

二、接口类 
# 接口类是一个规范
# 多种支付方式，每一种支付方式都是一个类
# 每一个类中定义一个支付方法完成支付功能
# 由于每一种支付方法完成支付功能
# 由于每一种支付方式在程序中表现出来的都是支付类的对象
# 为了方便支付方法的调用
# 需要统一一个入口，pay函数
# interface
# 在python里没有接口类这种数据类型，没有接口类专门的语法

from abc import ABCMeta,abstractmethod
class FlyAnimal(metaclass=ABCMeta):
    @abstractmethod
    def  fly(self):
        print('111')
class SwimAnimal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):pass
class WalkAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):pass
class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
    #飞
    def fly(self):pass
    #游泳
    def swim(self):pass
    #走
    def walk(self):pass
class Qq(SwimAnimal,WalkAnimal):
    #游泳
    def swim(self):pass
    #走
    def walk(self):pass
class Bird(FlyAnimal,WalkAnimal):
    #飞
    def fly(self):pass
    #走
    def walk(self):pass
Swan()
接口类不能被实例化

　　三、抽象类

# 抽象类 ，规范一个类的类
# 在python里抽象类和接口类没有区别
# word 文档是文件
# excel是文件
# ppt是文件

from abc import ABCMeta, abstractmethod
class File(metaclass=ABCMeta):
    @abstractmethod
    def read(self):
        f=open('file','r')
        self.f =f
    @abstractmethod
    def write(self):
        f = open('file','w')
class Word(File):
    def read(self):
        #打开一个文件
        #读文件
        #关闭一个文件
        super().read()
        self.f.read()
        self.f.close()
class Excel (File):
    def read(self):
    #打开一个文件
    #读某一列 读莫一列
    #关闭一个文件
class PPT(File):
    def read(self):
        #打开一个文件
        #读文字 读表格 读图片
        #关闭一个文件
        super().read()
        self.f.readpicture()
        self.f.close()
#

# 在java里 有区别
# java 的接口规定里面的方法一定不能实现(一句代码也不能写)
# 抽象类 单继承
无论接口类 还是抽象类 其实都是一种面向对象的编程的开发规范
# 只是在接口类或者抽象类中去约束继承他的子类必须实现某些方法
对于java代码来说：如果发生多继承，那么一定是接口类 且里面的方法都不能实现
如果在方法里有了实现 那么一定是单继承 的抽象类
# 但是对于python来说 就没有这些约束
# #因为python没有接口的概念
# #对于类的继承 没有多继承的限制.
# 实际上abc模块是帮助我们实现抽象类的方法，只是我们用他来模仿接口类的效果了
# 在python中，只要metaclass =ABCMeta定义了抽象方法(@abctractmethod)
# #这个类就不能被实例化
# #你可以说他是一个抽象类.

四、鸭子类型

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

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

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

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

例2：序列类型有多种形态：字符串，列表，元组，但他们直接没有直接的继承关系

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

    def write(self):
        pass

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