初識面向對象-接口類、抽象類、封裝（設計模式）（四）

接口類
設計模式介紹
http://www.cnblogs.com/tangkaishou/p/9246353.html
http://www.cnblogs.com/luhuajun/p/7442815.html

 # java ： 面向對象編程
# 設計模式 —— 接口
# 接口類 ： python原生不支持
# 抽象類 ： python原生支持的
from abc import abstractmethod,ABCMeta
class Payment(metaclass=ABCMeta): # 元類 默認的元類 type
 @abstractmethod
 def pay(self,money):pass # 沒有實現這個方法（來規範全部執行pay方法的代碼）
# 規範 ：接口類或者抽象類均可以
# 接口類 支持多繼承，接口類中的全部的方法都必須不能實現 —— java（pass位置不能有任何東西，必須是pass）
# 抽象類 不支持多繼承，抽象類中方法能夠有一些代碼的實現 —— java
class Wechat(Payment):
 def pay(self,money):
 print('已經用微信支付了%s元'%money)

class Alipay(Payment):
 def pay(self,money):
 print('已經用支付寶支付了%s元' % money)

class Applepay(Payment):
 def pay(self,money):
 print('已經用applepay支付了%s元' % money)

def pay(pay_obj,money): # 統一支付入口
 pay_obj.pay(money)

# wechat = Wechat()
# ali = Alipay()
app = Applepay()
# wechat.pay(100)
# ali.pay(200)
p = Payment()


 接口類的多繼承

（規範代碼，接口類自己不實現功能，主要檢測接口類裏的方法是否所有執行，防止漏掉或使用錯誤，繼承接口類，接口類內方法必須執行） 

# 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

# 接口類 恰好知足接口隔離（好比走、飛等，分開定義）原則 面向對象開發的思想 規範

抽象類

#一切皆文件
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這個概念來解決多繼承的規範問題（用Java語法來助於理解python的接口類和抽象類） 

# python
# python中沒有接口類 ：
 # python中自帶多繼承 因此咱們直接用class來實現了接口類
# python中支持抽象類 ： 通常狀況下 單繼承 不能實例化
 # 且能夠實現python代碼

多態

# 多態 python 天生支持多態（沒有實現多態的機制）
# 像Java必須定義一個父類Payment（無需實現功能），而後子類需繼承父類實現多態，好比Alipay、Applepay、pay在Java中必須繼承父類，pay才能知道Alipay、Applepay
# 是兄弟，而後實現他們多態

# def func(int num,str name):
# pass
#
# func('alex',2)
# class Payment:pass

# class Alipay():
# def pay(self,money):
# print('已經用支付寶支付了%s元' % money)
#
# class Applepay():
# def pay(self,money):
# print('已經用applepay支付了%s元' % money)
#
# def pay(pay_obj,money): # 統一支付入口 歸一化設計
# pay_obj.pay(money)
#
# pay()

# 什麼是多態
# python 動態強類型的語言（不能說是強類型語言，在2+‘str’會報錯表現出的是強類型，但在list tuple狀況無需繼承父類來實現多態，表現出的弱類型，因此說python是動態強類型語言）

）
# 鴨子類型
# list tuple
# 不崇尚根據繼承所得來的類似（不崇尚多態，而是崇尚鴨子類型，無需繼承父類去實現多態）

# 我只是本身實現我本身的代碼就能夠了。
# 若是兩個類恰好類似，並不產生父類的子類的兄弟關係，而是鴨子類型
# list tuple 這種類似，是本身寫代碼的時候約束的，而不是經過父類約束的
# 優勢 ： 鬆耦合 每一個類似的類之間都沒有影響
# 缺點 ： 太隨意了,只能靠自覺

# class List():
# def __len__(self):pass
# class Tuple():
# def __len__(self):pass
#
# def len(obj):
# return obj.__len__()
#
# l = Tuple()
# len(l)
#
# # 強類型語言 多態（其餘語言）（就像list和tuple，在其餘語言必須定義一個父類，List/Tuple/len去繼承父類，最後len（I)纔不會報錯，必須知道他們是兄弟纔給不報錯）
# # python 語言 鴨子類型（上面的List、len那種方式在python中就是鴨子類型，無需繼承父類）

# 接口類和抽象類 在python當中的應用點並非很是必要 
#爲何Java中要用接口類和抽象類這種方式去規範，由於Java沒鴨子類型。必須經過多態，定義一個父類擺設在那而後去繼承來規範
#若是面試問到來解釋下設計模式：對於咱們python學習者可能無法很清晰的表達，能夠這樣來解釋，在python中不崇尚採用繼承來規範代碼，例如list和tuple如此相像的類型都沒用繼承來規範，覺得崇尚鴨子類型

封裝

# 廣義上面向對象的封裝 ：代碼的保護，面向對象的思想自己就是一種
# 只讓本身的對象能調用本身類中的方法

# 狹義上的封裝 —— 面向對象的三大特性之一
# 屬性 和 方法都藏起來 不讓你看見
class Person:
 __key = 123 # 私有靜態屬性
 def __init__(self,name,passwd):
 self.name = name
 self.__passwd = passwd # 私有屬性（在python中定義私有並不由於數據安全，而是爲了避免讓調用）

 def __get_pwd(self): # 私有方法
 return self.__passwd #只要在類的內部使用私有屬性，就會自動的帶上_類名

 def login(self): # 正常的方法調用私有的方法
 self.__get_pwd()

alex = Person('alex','alex3714')
alex.__passwd = 1(在外部定義私有方面沒用，但會在self插入{‘_passwd’:1}屬性，這種定義只能在類的內部是發生）

print(alex._Person__passwd) # _類名__屬性名（有這個方式調用私有方式，不要這樣調，是不規範的操做）

print(alex.get_pwd())

# 全部的私有 都是在變量的左邊加上雙下劃綫
 # 對象的私有屬性
 # 類中的私有方法
 # 類中的靜態私有屬性
# 全部的私有的 都不能在類的外部使用
在python中沒有像Java中的public（公用）/private（私用），python不加雙下劃線__至關於public，加雙下劃線__就至關於private

# 昨天的複習和博客
# 今天的做業、複習
# 預習封裝的內容




複習

# 接口類 抽象類
# python中沒有接口類，有抽象類，abc模塊中的metaclass = ABCMeta，@abstructmethod
# 本質是作代碼規範用的，但願在子類中實現和父類方法名字徹底同樣的方法
# 在java的角度上看 是有區別的
 # java原本就支持單繼承 因此就有了抽象類
 # java沒有多繼承 因此爲了接口隔離原則，設計了接口這個概念，支持多繼承了
# python及支持單繼承也支持多繼承，因此對於接口類和抽象類的區別就不那麼明顯了
# 甚至在python中沒有內置接口類

# 多態和鴨子類型
# 多態 —— python天生支持多態
# 鴨子類型 —— 不依賴父類的狀況下實現兩個類似的類中的同名方法

# 封裝 —— 私有的
# 在python中只要__名字
# 在python中只要__名字，就把這個名字私有化了
# 私有化了以後 就不能能從類的外部直接調用了
# 靜態屬性 方法 對象屬性 均可以私有化
# 這種私有化只是從代碼級別作了變形，並無真的約束
# 變形機制 _類名__名字 在類外用這個調用，在類的內部直接__名字調用