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()

註釋：多態就是由於他們有相同的屬性，類調用時候不會報錯

 鴨子：他們的屬性都相同，就是一個鴨子。