Python面向对象（抽象类和接口类）
抽象类与接口类
1.接口类
#：第一版,原始版
class QQpay:
def pay(self,money):
print('你使用QQ支付了%s元' %money)
class Alipay:
def pay(self,money):
print('你使用阿里支付%s元' %money)
a = QQpay()
a.pay(50)
b = Alipay()
b.pay(23)
#===================================》
#:第二版，统一支付规则 统一pay接口
class QQpay:
def pay(self,money):
print('你使用QQ支付了%s元' %money)
class Alipay:
def pay(self,money):
print('你使用阿里支付%s元' %money)
def pay(obj,money):
obj.pay(money)
a = Alipay()
b = QQpay()
pay(a,100)
pay(b,200)
#======================================》
#第三版，来了一个新的程序猿，他不知道你的约定俗成的规矩，就会出问题
class QQpay:
def pay(self,money):
print('你使用QQ支付了%s元' %money)
class Alipay:
def pay(self,money):
print('你使用阿里支付%s元' %money)
class wechatpay:
def fuqian(self,money):
print('你使用微信支付%s元' %money)
def pay(obj,money):
obj.pay(money)
a = QQpay()
b = Alipay()
c = wechatpay()
pay(a,100)
pay(b,200)
c.fuqian(300) #---------》这里可以看出他直接不用你定义的规则
#======================================》
#第四版，解决上一版的问题
#定义一个父类，什么都不写，只是要求继承我的所有类有一个pay方法，这样就制定了一个规范，这就叫接口类
class Payment:
def pay(self):
pass
class QQpay(Payment):
def pay(self,money):
print('你使用QQ支付了%s元' %money)
class Alipay(Payment):
def pay(self,money):
print('你使用阿里支付%s元' %money)
class wechatpay(Payment):
def fuqian(self,money):
print('你使用微信支付%s元' %money)
def pay(obj,money):
obj.pay(money)
a = QQpay()
b = Alipay()
pay(a,100)
pay(b,200)
c = wechatpay()
c.fuqian(300)
#此时他看见你这些都继承了一个类，新来的程序猿便会去查看继承父类的内容
#第五版：最终版
#新来的程序猿虽说看了你定义的规范，但他就不照你的规范去执行，此时就需要让他强制执行此规范
from abc import ABCMeta,abstractmethod
class Payment(metaclass=ABCMeta):
@abstractmethod
def pay(self):
pass
class QQpay(Payment):
def pay(self,money):
print('你使用QQ支付了%s元' %money)
class Alipay(Payment):
def pay(self,money):
print('你使用阿里支付%s元' %money)
class wechatpay(Payment):
def fuqian(self,money):
print('你使用微信支付%s元' %money)
def pay(obj,money):
obj.pay(money)
a = QQpay()
b = Alipay()
pay(a,100)
pay(b,200)
c = wechatpay()
c.fuqian(300) #---------------》此时还这样便报错了
Can't instantiate abstract class wechatpay with abstract methods pay
接口提取了一群类共同的函数，可以把接口当做一个函数的集合。然后让子类去实现接口中的函数。这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
1.抽象类
什么是抽象类
与java一样，python也有抽象类的概念但是同样需要借助模块实现，抽象类是一个特殊的类，它的特殊之处在于只能被继承，不能被实例化
为什么要有抽象类
如果说类是从一堆对象中抽取相同的内容而来的，那么抽象类就是从一堆类中抽取相同的内容而来的，内容包括数据属性和函数属性。
比如我们有香蕉的类，有苹果的类，有桃子的类，从这些类抽取相同的内容就是水果这个抽象的类，你吃水果时，要么是吃一个具体的香蕉，要么是吃一个具体的桃子。。。。。。你永远无法吃到一个叫做水果的东西。
从设计角度去看，如果类是从现实对象抽象而来的，那么抽象类就是基于类抽象而来的。
从实现角度来看，抽象类与普通类的不同之处在于：抽象类中有抽象方法，该类不能被实例化，只能被继承，且子类必须实现抽象方法。
在Python中实现抽象类
from abc import ABCMeta,abstractmethod
class All_file(metaclass=ABCMeta):
all_type = 'file'
@abstractmethod
def read(self):
'子类必须定义读功能'
pass
@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('进程数据的读取方法')
a=Txt()
b=Sata()
c=Process()
#这样大家都是被归一化了,也就是一切皆文件的思想
a.read()
b.write()
c.read()
print(a.all_type)
print(b.all_type)
print(c.all_type)
抽象类和接口类
抽象类的本质还是类，指的是一组类的相似性，包括数据属性（如all_type）和函数属性（如read、write），而接口只强调函数属性的相似性。
抽象类是一个介于类和接口直接的一个概念，同时具备类和接口的部分特性，可以用来实现归一化设计
多继承问题
在继承抽象类的过程中，我们应该尽量避免多继承；
而在继承接口的时候，我们反而鼓励你来多继承接口
接口隔离原则：
使用多个专门的接口，而不使用单一的总接口。即客户端不应该依赖那些不需要的接口。
方法的实现
在抽象类中，我们可以对一些抽象方法做出基础实现；
而在接口类中，任何方法都只是一种规范，具体的功能需要子类实现
