Python接口类

1开发原则（七大原则）

一：开放封闭原则

二：接口隔离原则（将不一样接口对象一一展示出来，分别调用各自的接口，完成各自的功能）

三：依赖倒置原则

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

规范的定义：

• 高层模块不该该依赖低层模块，二者都应该依赖抽象
• 抽象不该该依赖细节
• 细节应该依赖抽象

本身的理解（抽象也就是将相同方法定义出来，方便调用）

 

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

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

 

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

class Payment(metaclass=ABCMeta):   #规范
    @abstractmethod
    def pay(self,money):
        '''
        :param money:
        :return:
        '''
        raise NotImplementedError

class ApplePay(Payment):# 100
    def pay(self,money):pass
app = ApplePay()
app.pay("我是参数")

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

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

from abc import ABCMeta,abstractmethod
# 接口类 : 接口类就是一个规范 接口类通常是项目设计人员写好的
class Payment(metaclass=ABCMeta):   #规范
    @abstractmethod
    def pay(self,money):
        '''
        :param money:
        :return:
        '''
        raise NotImplementedError

# class ApplePay(Payment):# 100
#     def pay(self,money):pass
# app = ApplePay()
# app.pay("我是参数")
# 微信支付
class WeChatPay(Payment):
    def pay(self,money):
        print('经过微信支付了%s元钱'%(money))

# 支付宝支付
class AliPay(Payment):
    def pay(self,money):

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

# apple pay
class ApplePay(Payment):
    def pay(self,money):
        print('经过支付宝支付了%s元钱' % (money))

wp = WeChatPay()
alp = AliPay()
app = ApplePay()
def pay(pay_obj,money): # 程序的归一化设计
    pay_obj.pay(money)

pay(alp,100)
pay(wp,100)
pay(app,100)

打印结果：

经过支付宝支付了100元钱
经过微信支付了100元钱
经过支付宝支付了100元钱

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

 

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

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

from abc import ABCMeta,abstractmethod
class FlyAnimal(metaclass=ABCMeta):
    @abstractmethod
    def fly(self):
        print(11111)

class SwimAnimal(metaclass=ABCMeta):
    @abstractmethod
    def swim(self): pass

class WalkAnimal(metaclass=ABCMeta):
    @abstractmethod
    def walk(self): pass

class Swan(SwimAnimal,WalkAnimal,FlyAnimal):
    # 飞
    def fly(self):pass
    # 游泳
    def swim(self):pass
    # 走
    def walk(self):pass

class Qq(SwimAnimal,WalkAnimal):
    def swim(self):pass
    # 走
    def walk(self):pass

class Bird(FlyAnimal,WalkAnimal):
    # 飞
    def fly(self):pass
    # 走
    def walk(self):pass

Swan()
# 接口类不能被实例化

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

          接口类不能实例化

 

例子4：抽象类

# 抽象类  规范一个类的类
# 在python里 抽象类和接口类 没区别
# word文档是文件
# excle是文件
# ppt是文件
from abc import ABCMeta , abstractmethod
class File(metaclass=ABCMeta):
    @abstractmethod
    def read(self):
        f = open('file','r')
        self.f = f
    @abstractmethod
    def write(self):
        f = open('file','w')

class Word(File):
    def read(self):
        # 打开一个文件
        # 读文件
        # 关闭一个文件
        super().read()
        self.f.read()
        self.f.close()

class Excle(File):
    def read(self):
        # 打开一个文件
        # 读某一列  读某一列
        # 关闭一个文件
        super().read()
        self.f.readline()
        self.f.close()

class PPT(File):
    def read(self):
        # 打开一个文件
        # 读文字 读表格 读图片
        # 关闭一个文件
        super().read()
        self.f.readpicture()
        self.f.close()

注释：

在java里 有区别
java的接口规定里面的方法必定不能实现(一句代码也不能写)
抽象类 单继承

不管接口类 仍是抽象类 其实都是一种面向对象编程的开发规范
只是在接口类或者抽象类中 去约束继承它的子类必须实现某些方法
对于java代码来讲:若是发生多继承 那么必定是接口类 且里面的方法都不能实现
                 若是在方法里有了实现 那么必定是单继承 的抽象类
可是对于python来讲 就没有这些约束
    由于python没有接口的概念
    对于类的继承 没有多继承的限制
实际上abc模块是帮我实现抽象类的方法,只是咱们用它来模仿接口类的效果了

在python中,只要metaclass = ABCMeta 定义了抽象方法(@abctractmethod)
    这个类就不能被实例化
    你能够说他是一个抽象类

多态与鸭子类型：

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

多态：

import abc
class Animal(metaclass=abc.ABCMeta): #同一类事物:动物
    @abc.abstractmethod
    def talk(self):
        pass

class People(Animal): #动物的形态之一:人
    def talk(self):
        print('say hello')

class Dog(Animal): #动物的形态之二:狗
    def talk(self):
        print('say wangwang')

class Pig(Animal): #动物的形态之三:猪
    def talk(self):
        print('say aoao')

peo=People()
dog=Dog()
pig=Pig()

#peo、dog、pig都是动物,只要是动物确定有talk方法
#因而咱们能够不用考虑它们三者的具体是什么类型,而直接使用
peo.talk()
dog.talk()
pig.talk()

#更进一步,咱们能够定义一个统一的接口来使用
def func(obj):
    obj.talk()

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

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