Python- 接口类-抽象类

Posted 2020-11-21 o微凉o

接口类

继承有两种用途：

一：继承基类的方法，并且做出自己的改变或者扩展（代码重用）  

二：声明某个子类兼容于某基类，定义一个接口类Interface，接口类中定义了一些接口名（就是函数名）且并未实现接口的功能，子类继承接口类，并且实现接口中的功能

  1 # 一:这样不好,我要统一一下支付的规则.
  2 
  3 class QQpay:
  4     def pay(self,money):
  5         print(‘使用qq支付%s元‘ % money)
  6 
  7 class Alipay:
  8     def pay(self,money):
  9         print(‘使用阿里支付%s元‘ % money)
 10 
 11 a = Alipay()
 12 a.pay(100)
 13 
 14 b = QQpay()
 15 b.pay(200)
 16 
 17 # 二,统一支付的规则 归一化设计,统一 pay接口
 18 class QQpay:
 19     def pay(self,money):
 20         print(‘使用qq支付%s元‘ % money)
 21 
 22 class Alipay:
 23     def pay(self,money):
 24         print(‘使用阿里支付%s元‘ % money)
 25 
 26 def pay(obj,money):
 27     obj.pay(money)
 28 
 29 a = Alipay()
 30 b = QQpay()
 31 
 32 pay(a,100)
 33 pay(b,200)
 34 
 35 # 三,但是,来了一个野生程序员,他不知道你的约定俗成的规则,就会出问题
 36 
 37 class QQpay:
 38     def pay(self,money):
 39         print(‘使用qq支付%s元‘ % money)
 40 
 41 class Alipay:
 42     def pay(self,money):
 43         print(‘使用阿里支付%s元‘ % money)
 44 
 45 class Wechatpay:
 46     def fuqian(self,money):
 47         print(‘使用微信支付%s元‘ % money)
 48 
 49 def pay(obj,money):
 50     obj.pay(money)
 51 
 52 a = Alipay()
 53 b = QQpay()
 54 
 55 pay(a,100)
 56 pay(b,200)
 57 
 58 c = Wechatpay()
 59 c.fuqian(300)
 60 
 61 # 四,解决方式
 62 # 定义一个父类,什么都不写,只是要求继承我的所有类有一个pay方法,这样就制定了一个规范,这就叫做接口类,后者抽象类.
 63 class Payment:
 64     def pay(self):pass
 65 
 66 class QQpay(Payment):
 67     def pay(self,money):
 68         print(‘使用qq支付%s元‘ % money)
 69 
 70 class Alipay(Payment):
 71     def pay(self,money):
 72         print(‘使用阿里支付%s元‘ % money)
 73 
 74 class Wechatpay(Payment):
 75     def fuqian(self,money):
 76         print(‘使用微信支付%s元‘ % money)
 77 
 78 
 79 def pay(obj,money):
 80     obj.pay(money)
 81 
 82 a = Alipay()
 83 b = QQpay()
 84 
 85 pay(a,100)
 86 pay(b,200)
 87 
 88 c = Wechatpay()
 89 c.fuqian(300)
 90 
 91 #五,他还是不知道看你这些都继承了一个类,所以你要制定一个规范,强制他执行.
 92 # 创建一个规范
 93 from abc import ABCMeta,abstractmethod
 94 class Payment(metaclass=ABCMeta):    # 抽象类 接口类  规范和约束  metaclass指定的是一个元类
 95     @abstractmethod
 96     def pay(self):pass  # 抽象方法
 97 
 98 class Alipay(Payment):
 99     def pay(self,money):
100         print(‘使用支付宝支付了%s元‘%money)
101 
102 class QQpay(Payment):
103     def pay(self,money):
104         print(‘使用qq支付了%s元‘%money)
105 
106 class Wechatpay(Payment):
107     # def pay(self,money):
108     #     print(‘使用微信支付了%s元‘%money)
109     def recharge(self):pass
110 
111 def pay(a,money):
112     a.pay(money)
113 
114 a = Alipay()
115 a.pay(100)
116 pay(a,100)    # 归一化设计：不管是哪一个类的对象，都调用同一个函数去完成相似的功能
117 q = QQpay()
118 q.pay(100)
119 pay(q,100)
120 w = Wechatpay()
121 pay(w,100)   # 到用的时候才会报错
122 
123 
124 
125 # 抽象类和接口类做的事情 ：建立规范
126 # 制定一个类的metaclass是ABCMeta，
127 # 那么这个类就变成了一个抽象类(接口类)
128 # 这个类的主要功能就是建立一个规范
129 
130 接口类示例

View Code

实践中，继承的第一种含义意义并不很大，甚至常常是有害的。因为它使得子类与基类出现强耦合。

继承的第二种含义非常重要。它又叫“接口继承”。
接口继承实质上是要求“做出一个良好的抽象，这个抽象规定了一个兼容接口，使得外部调用者无需关心具体细节，可一视同仁的处理实现了特定接口的所有对象”——这在程序设计上，叫做归一化。

归一化使得高层的外部使用者可以不加区分的处理所有接口兼容的对象集合——就好象linux的泛文件概念一样，所有东西都可以当文件处理，不必关心它是内存、磁盘、网络还是屏幕（当然，对底层设计者，当然也可以区分出“字符设备”和“块设备”，然后做出针对性的设计：细致到什么程度，视需求而定）。

 

依赖倒置原则：
高层模块不应该依赖低层模块，二者都应该依赖其抽象；抽象不应该应该依赖细节；细节应该依赖抽象。换言之，要针对接口编程，而不是针对实现编程

　　

在python中根本就没有一个叫做interface的关键字，上面的代码只是看起来像接口，其实并没有起到接口的作用，子类完全可以不用去实现接口 ，如果非要去模仿接口的概念，可以借助第三方模块：

http://pypi.python.org/pypi/zope.interface

twisted的twistedinternetinterface.py里使用zope.interface

文档https://zopeinterface.readthedocs.io/en/latest/

设计模式：https://github.com/faif/python-patterns

 1 接口提取了一群类共同的函数，可以把接口当做一个函数的集合。
 2 
 3 然后让子类去实现接口中的函数。
 4 
 5 这么做的意义在于归一化，什么叫归一化，就是只要是基于同一个接口实现的类，那么所有的这些类产生的对象在使用时，从用法上来说都一样。
 6 
 7 归一化，让使用者无需关心对象的类是什么，只需要的知道这些对象都具备某些功能就可以了，这极大地降低了使用者的使用难度。
 8 
 9 比如：我们定义一个动物接口，接口里定义了有跑、吃、呼吸等接口函数，这样老鼠的类去实现了该接口，松鼠的类也去实现了该接口，由二者分别产生一只老鼠和一只松鼠送到你面前，即便是你分别不到底哪只是什么鼠你肯定知道他俩都会跑，都会吃，都能呼吸。
10 
11 再比如：我们有一个汽车接口，里面定义了汽车所有的功能，然后由本田汽车的类，奥迪汽车的类，大众汽车的类，他们都实现了汽车接口，这样就好办了，大家只需要学会了怎么开汽车，那么无论是本田，还是奥迪，还是大众我们都会开了，开的时候根本无需关心我开的是哪一类车，操作手法（函数调用）都一样

为什么使用接口