1

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):#100
    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

 



posted @ 2018-03-08 16:21  萌哥-爱学习  阅读(238)  评论(0编辑  收藏  举报