接口类

继承有两种用途:继承基类的方法,并且做出自己的改变或扩展(代码重用)和声明某个子类兼容于某基类,定义一个接口类interface,接口类中定义了一些接口名(就是函数名)且并未实现接口的功能,子类继承接口类,并且实现接口的功能

比如说一种支付方式有三种不同的途径:Alipay、Applepay、Wechatpay

如果现在只有两种支付方式Alipay和Wechatpay,我们该如何去实现支付的方法呢？

class Wechat:
    def pay(self,money):
        print('已经用了微信支付了%s元'%money)
class Alipay:
    def pay(self,money):
        print('已经用了支付宝支付了%s元'%money)
wechat = Wechat()
wechat.pay(200)             #已经用了微信支付了200元
ali = Alipay()
ali.pay(150)                #已经用了支付宝支付了150元

但是这样做有一点不好就是用户要去关心他在支付的时候是用什么方式去pay的,而我们只需要传一个支付的对象和钱就好了

def pay(obj_pay,money):     #定义一个支付函数
    obj_pay.pay(money)
class Wechat:
    def pay(self,money):
        print('已经用了微信支付了%s元'%money)
class Alipay:
    def pay(self,money):
        print('已经用了支付宝支付了%s元'%money)
wechat = Wechat()
pay(wechat,300)             #已经用了微信支付了300元
ali = Alipay()
pay(ali,250)                #已经用了支付宝支付了250元

这样写虽然可以,但是假设在之后添加了一个新的类Applepay的付款方式,里面的方法名和pay名不同就会导致报错

from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta):
    @abstractmethod
    def pay(self,money):
        raise NotImplemented

class Wechat(Payment):
    def pay(self,money):
        print('已经用了微信支付了%s元'%money)
class Alipay(Payment):
    def pay(self,money):
        print('已经用了支付宝支付了%s元'%money)
class Apple(Payment):
    def payMoney(self,money):
        print('已经用了支付宝支付了%s元'%money)

wechat = Wechat()
ali = Alipay()
apple = Apple()         #Can't instantiate abstract class Apple with abstract methods pay

这样的话如果开发人员写的方法名和pay不同时,程序在实例化对象就会报错就直接给给开发人员提示了要用规范的方法去写。如果我们再把Apple类中的方法给改回pay的方法名,那么就不会报错了

class Apple(Payment):
    def pay(self,money):
        print('已经用了支付宝支付了%s元'%money)

apple = Apple()

接口的多继承

如果我们归纳下面三种动物的行为,老虎能走路、游泳;天鹅能飞、走路、游泳;老鹰能走路、飞，我们该如何用接口的方法去表示呢?

from abc import abstractmethod,ABCMeta
class Swim_Behavior(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):
        pass
class Walk_Behavior(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):
        pass
class Fly_Behavior(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        pass

class Tiger(Swim_Behavior,Walk_Behavior):
    def walk(self):
        print('Can walk!')
    def swim(self):
        print('Can swim!')

class Swan(Swim_Behavior,Walk_Behavior,Fly_Behavior):
    def walk(self):
        print('Can walk!')
    def swim(self):
        print('Can swim!')
    def fly(self):
        print('Can fly!')

class Hawk(Walk_Behavior,Fly_Behavior):
    def walk(self):
        print('Can walk!')
    def fly(self):
        print('Can fly!')

t = Tiger()
s = Swan()
h = Hawk()

接口类本身的方法不实现只是起到规范的作用

接口隔离原则:

使用多个专门的接口,而不使用单一的总接口。即客户端不应该依赖那些不需要的接口

专门的接口指的是上面的动物能walk就用walk的接口,能fly就用fly的接口,能swim就用swim的接口

不使用单一的接口指的是不应该使用一个接口里面既能有walk的行为又有fly的行为等,只有这样把每一个功能都隔离开,我们在后面用到这个功能就能够继承到它所有相关变量名和方法名

即客户端不应该依赖那些不需要的接口指的是创建了一个Tiger类不应该要那些自己本身没有的类,比如fly

 

抽象类

抽象类是一个特殊的类,它的特殊之处在于只能被继承,不能被实例化

如果说类是从一堆对象中抽取相同的内容而来的,那么抽象类就是从一堆类中抽取相同的内容而来的,内容包括数据属性和函数属性

#在操作系统中一切皆文件
from abc import abstractmethod,ABCMeta
class All_file(metaclass=ABCMeta):
    all_type = 'file'               #所有的类型都是文件
    @abstractmethod                 #定义一个抽象方法无需实现功能
    def write(self):
        pass
    @abstractmethod                 #定义一个抽象方法无需实现功能
    def read(self):
        pass

class Txt(All_file):                #定义一个Txt类,子类继承抽象类,但是必须定义一个write和read的方法
    def write(self):
        print('Write something...')
    def read(self):
        print('Read something...')

class Sata(All_file):               #定义一个Sata类,子类继承抽象类,但