19 接口类和抽象类

接口类和抽象类的界限比较模糊。

接口类

python原生是不支持的，支持多继承，接口类中的所有方法都必须不能实现，不能实例化

抽象类

python原生支持的，不支持多继承，抽象类中方法可以有一些代码实现。不能实例化。

class Wechat:
	def pay(self,money):
		print('微信支付')
class Alipay():
	def pay(self,money):
		print('支付宝支付')
def pay(pay_obj,money):
	pay_obj.pay(money)
wechat = Wechat()
ali = Alipay()
wechat.pay(100)
ali.pay(200)
#等价于
#pay(wechat,100)
#pay(ali,200)

上述中def pay(pay_obj,money):就统一了支付的入口。

from abc import abstractmethod,ABCMeta
class Payment(metaclass= ABCMeta): #metaclass表示一个元类，将自己写的父类方法设置为默认的元类
    @abstractmethod
    def pay(self,money):
        raise NotImplemented  # 没有实现这个方法
#上述的Payment方法实现了一个规范，这个就是一个接口类，或者抽象类。

class Wechat(Payment):
    def pay(self, money):
        print('微信支付')


class Alipay(Payment):
    def pay(self, money):
        print('支付宝支付')

class Applepay():
    def fuqian(self, money):
        print('Apple支付')

def pay(pay_obj, money):
    pay_obj.pay(money)


# wechat = Wechat()
# ali = Alipay()
apple = Applepay()
# wechat.pay(100)
# ali.pay(200)
# 等价于
# pay(wechat, 100)
# pay(ali, 200)
pay(apple,300)

接口类与抽象类的区别

接口类，多继承父类，同时继承的方法必须要写出来。如果不写，会报错。
再规定规则的时候，方法不需要实现，但是必须再子类中实现。

from abc import ABCMeta, abstractmethod


class swim_Animal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self):
        raise NotImplemented  # 没有实现这个方法


class walk_Animal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self):
        raise NotImplemented  # 没有实现这个方法


class fly_Animal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        raise NotImplemented  # 没有实现这个方法


class Eagle(walk_Animal, fly_Animal):
    def walk(self):
        print('go')

    def fly(self):
        print('fly')


class Tiger(walk_Animal, swim_Animal):
    def walk(self):
        print('go')

    def swim(self):
        print('swin')


class Swan(walk_Animal, swim_Animal, fly_Animal):
    def walk(self):
        print('go')

    def swim(self):
        print('swin')

    def fly(self):
        print('fly')


s = Swan()
s.swim()

抽象类，也是一种规范，一般情况下，是单继承，都是能实现的功能都是一样的，所以可以再父类中有一些简单的基础实现。
多继承的情况，由于功能比较复杂，所以不容易抽象出相同的功能的具体实现写在父类中。

import abc #利用abc模块实现抽象类

class All_file(metaclass=abc.ABCMeta):
    all_type='file'
    @abc.abstractmethod #定义抽象方法，无需实现功能
    def read(self):
        '子类必须定义读功能'
        with open('filaname') as f:
            pass

    @abc.abstractmethod #定义抽象方法，无需实现功能
    def write(self):
        '子类必须定义写功能'
        pass

class Txt(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('文本数据的读取方法')
    def write(self):
        print('文本数据的读取方法')

class Sata(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('硬盘数据的读取方法')

    def write(self):
        print('硬盘数据的读取方法')

class Process(All_file): #子类继承抽象类，但是必须定义read和write方法
    def read(self):
        print('进程数据的读取方法')

    def write(self):
        print('进程数据的读取方法')