# 介面類：python 原生不支持# 抽象類：python 原生支持的 介面類 首先我們來看一個支付介面的簡單例子 介面類的多繼承 這是三種動物tiger 走路 游泳swan 走路 游泳 飛oldying 走路 飛 為了避免代碼重覆，我們寫以下三個類下麵就是實現了 介面類的規範 不需要有功能實現的 ...
# 介面類：python 原生不支持
# 抽象類：python 原生支持的
介面類
首先我們來看一個支付介面的簡單例子
from abc import abstractmethod,ABCMeta #我們也可以創建一個規範類 class Payment(metaclass=ABCMeta): # 元類 預設的元類 type @abstractmethod def pay(self,money): raise Notlmplemented #規範類要求需要實現一個 叫做 pay 的方法 #這樣在不調用的情況下 就會拋出錯誤 在實例化時就可以發現這個問題 # 規範 ：介面類或者抽象類都可以 # 介面類 支持多繼承，介面類中的所有的方法都必須不能實現 —— java # 抽象類 不支持多繼承，抽象類中方法可以有一些代碼的實現 —— java class Payment: def pay(self,money): #2.沒有實現該方法，就會拋出這個異常,用來隱藏 1 處的錯誤 raise Notlmplemented #原理就是 如果不實現 pay 方法 就會拋出這個報錯 #報錯如下 #NameError: name 'Notlmplemented' is not defined class Weipay(Payment): def pay(self,money): print('微信支付了%s元'%money) class Alipay(Payment): def pay(self,money): print('支付寶支付了%s元'%money) class Apppay(Payment): def pays(self,money): #1.如果這裡的 pay 換成了其他名字就會報錯 與下麵的 pay 函數衝突了 print('蘋果支付了%s元'%money) wei = Weipay() ali = Alipay() app = Apppay() def pay(pay_obj,money): pay_obj.pay(money) pay(wei,100) pay(ali,100) pay(app,100) #weipay.pay(100) #alipay.pay(100)
介面類的多繼承
這是三種動物
tiger 走路 游泳
swan 走路 游泳 飛
oldying 走路 飛
為了避免代碼重覆，我們寫以下三個類
下麵就是實現了 介面類的規範 不需要有功能實現的代碼
#下麵就是實現了 介面類的規範 不需要有功能實現的代碼 from abc import abstractmethod,ABCMeta class Swim_Animal(metaclass=ABCMeta): @abstractmethod def swim(self):pass class Walk_Animal(metaclass=ABCMeta): @abstractmethod def walk(self):pass class Fly_Animal(metaclass=ABCMeta): @abstractmethod def fly(self):pass #繼承了類裡面的相應的方法就必須要寫 class Tiger(Walk_Animal,Swim_Animal): def walk(self): pass def swim(self): pass class OldYing(Fly_Animal,Walk_Animal):pass class Swan(Swim_Animal,Walk_Animal,Fly_Animal):pass # 這樣就完了 介面類 剛好滿足介面隔離原則 面向對象開發的思想 規範
python 中沒有介面類 這個只是類似，就是說 我要實現不同的功能，我就去繼承不同的介面，來規範我當前類中要用那些函數
好了我們接下來稍稍完善下上滿的例子
from abc import abstractmethod,ABCMeta class Swim_Animal(metaclass=ABCMeta): @abstractmethod def swim(self):pass class Walk_Animal(metaclass=ABCMeta): @abstractmethod def walk(self):pass class Fly_Animal(metaclass=ABCMeta): @abstractmethod def fly(self):pass class Tiger(Walk_Animal,Swim_Animal): def walk(self,num): print('獅子跑了 %s 公裡'%num) def swim(self,num): print('獅子游了 %s 公裡'%num) class OldYing(Fly_Animal,Walk_Animal): def fly(self,num): print('老鷹飛了 %s 公裡'%num) def walk(self,num): print('老鷹跑了 %s 公裡'%num) class Swan(Swim_Animal,Walk_Animal,Fly_Animal): def fly(self,num): print('天鵝飛了 %s 公裡'%num) def walk(self,num): print('天鵝跑了 %s 公裡'%num) def swim(self,num): print('天鵝游了 %s 公裡'%num) T = Tiger() o = OldYing() s = Swan() #s.fly(5) def action(action_obj,num): action_obj(num) action(s.fly,5)
抽象類
如果說類是從一堆對象中抽取相同的內容而來的，那麼抽象類就是從一堆類中抽取相同的內容而來的，內容包括數據屬性和函數屬性
在 python 中實現抽象類，抽象類一般是單繼承
操作系統一切皆文件
我們來實現一個抽象類
import abc #利用 abc 模塊實現抽象類 class All_file(metaclass=abc.ABCMeta): all_type='file' @abc.abstractmethod #定義抽象方法，無需實現功能 def read(self): '子類必須定義讀功能' with open('filaname') as f: pass @abc.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('進程數據的讀取方法') wenbenwenjian=Txt() yingpanwenjian=Sata() jinchengwenjian=Process() #這樣大家都是被歸一化了,也就是一切皆文件的思想 wenbenwenjian.read() yingpanwenjian.write() jinchengwenjian.read() print(wenbenwenjian.all_type) print(yingpanwenjian.all_type) print(jinchengwenjian.all_type)
抽象類 ： 規範
一般情況下 單繼承 能實現的功能都是一樣的，所以在父類中可以有一些簡單的基礎實現
多繼承的情況 由於功能比較複雜，所以不容易抽象出相同的功能的具體實現寫在父類中
抽象類還是介面類 ： 面向對象的開發規範 所有的介面類和抽象類都不能實例化
java：
java里的所有類的繼承都是單繼承,所以抽象類完美的解決了單繼承需求中的規範問題
但對於多繼承的需求，由於java本身語法的不支持，所以創建了介面Interface這個概念
來解決多繼承的規範問題
python：
python中沒有介面類 ：
python中自帶多繼承 所以我們直接用class來實現了介面類
python中支持抽象類 ： 一般情況下 單繼承 不能實例化（介面類抽象類）
且可以實現python代碼
多態
python 天生支持多態，python 是動態強類型的語言
多態指的是一類事物有多種形態
動物有多種形態：人，狗，豬
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') People().talk()
文件有多種形態：文本文件，可執行文件
多態性
什麼是多態動態綁定（在繼承的背景下使用時，有時也稱為多態性）
多態性是指在不考慮實例類型的情況下使用實例
在面向對象方法中一般是這樣表述多態性：
向不同的對象發送同一條消息（ ！！！obj.func():是調用了obj的方法func，又稱為向 obj 發送了一條消息 func ），不同的對象在接收時會產生不同的行為（即方法）。
也就是說，每個對象可以用自己的方式去響應共同的消息。所謂消息，就是調用函數，不同的行為就是指不同的實現，即執行不同的函數。
比如：老師.下課鈴響了（），學生.下課鈴響了()，老師執行的是下班操作，學生執行的是放學操作，雖然二者消息一樣，但是執行的效果不同
鴨子類型
# 鴨子類型
# list tuple 如果說兩個類型為鴨子類型 就是說這兩個類型很相識
# 不崇尚根據繼承所得來的相似
# 我只是自己實現我自己的代碼就可以了。
# 如果兩個類剛好相似，並不產生父類的子類的兄弟關係，而是鴨子類型
# list tuple 這種相似，是自己寫代碼的時候約束的，而不是通過父類約束的
# 優點：松耦合 每個相似的類之間都沒有影響
# 缺點：太隨意了,只能靠自覺
# 介面類和抽象類 在 python 當中的應用點並不是非常必要
封裝
# 廣義上面向對象的封裝 ：代碼的保護，面向對象的思想本身就是一種
# 只讓自己的對象能調用自己類中的方法
# 狹義上的封裝 —— 面向對象的三大特性之一
# 屬性 和 方法都藏起來 不讓你看見
class Person: __key = 123 # 私有靜態屬性 def __init__(self,name,passwd): self.name = name #self.passwd = passwd self.__passwd = passwd #當屬性前面加上 __ 就成為了私有屬性 def get_pwd(self): #在類的內部使用方法調用 __passwd 屬性 print(self.__dict__) return self.__passwd #只要在類的內部使用私有屬性，就會自動的帶上_類名 def __login(self): #私有方法 self.__get.pwd() per = Person('ysg','123') #print(alex.passwd) #print(per.__passwd) #然後就找不到該屬性了 print(per.__dict__) #這裡還是可以看到 所有私有屬性並不是約束數據安全的只是在代碼級別加了一層密 print(per._Person__passwd) # _類名__屬性名 這樣調用就可以了 不過不應該去調取 print(per.get_pwd()) print(per.__login) #調取不到 #定義類的私有屬性 只能在類的內部 外部就不可以 per.__high = 1 print(per.__high) #外部就可以直接使用
所有的私有 都是在變數的左邊加上雙下劃線
對象的私有屬性
類中的私有方法
類中的靜態私有屬性
所有的私有的 都不能在類的外部使用
