python定义接口_python接口类 - zhujun2017的个人空间 - OSCHINA - 中文开源技术交流社区...

1开发原则(七大原则)

一：开放封闭原则

二：接口隔离原则(将不同接口对象一一展现出来，分别调用各自的接口，完成各自的功能)

三：依赖倒置原则

高级模块不能依赖低级模块，可以依赖抽象

规范的定义：

高层模块不应该依赖低层模块，两者都应该依赖抽象

抽象不应该依赖细节

细节应该依赖抽象

自己的理解(抽象也就是将相同方法定义出来，方便调用)

2 在开发的时候要遵循设计模式，和开发原则

3 在Python里，没有接口的概念，在Java里才有接口的概念，但是可以通过继承abc模块来实现接口的功能

例题1  ：正常情况下调用一个类

classPayment(metaclass=ABCMeta): #规范

@abstractmethod

defpay(self,money):

'''

:param money:

:return:

'''

raiseNotImplementedError

classApplePay(Payment):# 100

defpay(self,money):passapp = ApplePay()

app.pay("我是参数")

解释：定义一个类，然后调用一个类

例题2：为了避免没有使用接口类含有的方法，方面测试人员检查是否调用接口

fromabc importABCMeta,abstractmethod

# 接口类 : 接口类就是一个规范 接口类一般是项目设计人员写好的

classPayment(metaclass=ABCMeta): #规范

@abstractmethod

defpay(self,money):

'''

:param money:

:return:

'''

raiseNotImplementedError

# class ApplePay(Payment):# 100

# def pay(self,money):pass

# app = ApplePay()

# app.pay("我是参数")

# 微信支付

classWeChatPay(Payment):

defpay(self,money):

print('通过微信支付了%s元钱'%(money))

# 支付宝支付

classAliPay(Payment):

defpay(self,money):

print('通过支付宝支付了%s元钱'%(money))

# apple pay

classApplePay(Payment):

defpay(self,money):

print('通过支付宝支付了%s元钱' % (money))

wp = WeChatPay()

alp = AliPay()

app = ApplePay()

defpay(pay_obj,money): # 程序的归一化设计

pay_obj.pay(money)

pay(alp,100)

pay(wp,100)

pay(app,100)

打印结果：

通过支付宝支付了100元钱

通过微信支付了100元钱

通过支付宝支付了100元钱

注意：即执行了各个方法，又检测了是否调用了这个接口。

例题3  天鹅，企鹅，鸟 使用接口离原则(接口类)

使用多个单一的接口，不使用单一的总接口。

fromabc importABCMeta,abstractmethod

classFlyAnimal(metaclass=ABCMeta):

@abstractmethod

deffly(self):

print(11111)

classSwimAnimal(metaclass=ABCMeta):

@abstractmethod

defswim(self): pass

classWalkAnimal(metaclass=ABCMeta):

@abstractmethod

defwalk(self): pass

classSwan(SwimAnimal,WalkAnimal,FlyAnimal):

# 飞

deffly(self):pass# 游泳

defswim(self):pass# 走

defwalk(self):pass

classQq(SwimAnimal,WalkAnimal):

defswim(self):pass# 走

defwalk(self):pass

classBird(FlyAnimal,WalkAnimal):

# 飞

deffly(self):pass# 走

defwalk(self):pass

Swan()

# 接口类不能被实例化

注释：swan,qq,bird，分别调用他们自身需要的接口，接收属性，不需要的不接收

接口类不能实例化

例子4：抽象类

# 抽象类 规范一个类的类

# 在python里 抽象类和接口类 没区别

# word文档是文件

# excle是文件

# ppt是文件

fromabc importABCMeta , abstractmethod

classFile(metaclass=ABCMeta):

@abstractmethod

defread(self):

f = open('file','r')

self.f = f

@abstractmethod

defwrite(self):

f = open('file','w')

classWord(File):

defread(self):

# 打开一个文件

# 读文件

# 关闭一个文件

super().read()

self.f.read()

self.f.close()

classExcle(File):

defread(self):

# 打开一个文件

# 读某一列 读某一列

# 关闭一个文件

super().read()

self.f.readline()

self.f.close()

classPPT(File):

defread(self):

# 打开一个文件

# 读文字 读表格 读图片

# 关闭一个文件

super().read()

self.f.readpicture()

self.f.close()

注释：

在java里 有区别

java的接口规定里面的方法一定不能实现(一句代码也不能写)

抽象类 单继承

无论接口类 还是抽象类 其实都是一种面向对象编程的开发规范

只是在接口类或者抽象类中 去约束继承它的子类必须实现某些方法

对于java代码来说:如果发生多继承 那么一定是接口类 且里面的方法都不能实现

如果在方法里有了实现 那么一定是单继承 的抽象类

但是对于python来说 就没有这些约束

因为python没有接口的概念

对于类的继承 没有多继承的限制

实际上abc模块是帮我实现抽象类的方法,只是我们用它来模仿接口类的效果了

在python中,只要metaclass = ABCMeta 定义了抽象方法(@abctractmethod)

这个类就不能被实例化

你可以说他是一个抽象类

多态与鸭子类型：

多态比鸭子类型多了一个抽象类(将不同类的同一个属性抽离出来)。

多态：

importabc

classAnimal(metaclass=abc.ABCMeta): #同一类事物:动物

@abc.abstractmethod

deftalk(self):

pass

classPeople(Animal): #动物的形态之一:人

deftalk(self):

print('say hello')

classDog(Animal): #动物的形态之二:狗

deftalk(self):

print('say wangwang')

classPig(Animal): #动物的形态之三:猪

deftalk(self):

print('say aoao')

peo=People()

dog=Dog()

pig=Pig()

#peo、dog、pig都是动物,只要是动物肯定有talk方法

#于是我们可以不用考虑它们三者的具体是什么类型,而直接使用

peo.talk()

dog.talk()

pig.talk()

#更进一步,我们可以定义一个统一的接口来使用

deffunc(obj):

obj.talk()

注释：多态就是因为他们有相同的属性，类调用时候不会报错

鸭子：他们的属性都相同，就是一个鸭子。