抽象類,接口類

抽象類有固定的寫法(制定規範),制定規範後,必須按照規範的方法來寫後面的執行方法,否則程序就會報錯

代碼:

普通方法寫兩個支付的方法

class Ali:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print(‘使用支付寶支付了%s元‘ % (self.money))
class Jd:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print
 
(‘在京東支付了%s元‘ % (self.money))
a1=Ali(100)
a1.pay()

a2=Jd(200)
a2.pay()

歸一化設計

class Ali:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print(‘在支付寶使用了%s元‘ % self.money)
class Jd:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print(‘在京東使用了%s元‘ % self.money)
def fu(ob):     #定義一個函數,這個函數的形參接收實例化的對象
    ob.pay()       #這個函數的功能必須要跟類裏的函數方法一樣,因為這裏是調用類裏的函數方法(都是支付方法),ob接收的實例化的對象
                   #執行的時候就相當於  對象.pay()   ,所以執行的實際上是類裏面的pay(self)方法‘‘‘
a1=Ali(100)
fu(a1)          #歸一化設計   ,  把實例化的對象當做實參傳給ob這個形參,傳過去就相當於a1.pay()這種形式
                #用歸一化設計就不用每次執行程序時都要去手動調用函數,用歸一化設計只需要實例化一個對象就行了,剩下的就由程序自己執行
a2=Jd(200)
fu(a2)

歸一化設計的漏洞

class Ali:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print(‘在支付寶中使用了%s元‘ % self.money)
class Jd:
    def __init__(self,money):
        self.money=money
    def pay(self):
        print(‘在京東使用了%s元‘ % self.money)
class Wx:
    def __init__(self,money):
        self.money=money
    def po(self):
        print(‘在微信中使用了%s元‘ % self.money)
        # class Wx這個類中的方法就是歸一化設計的漏洞,雖然程序可以執行,
        # 但是這個類裏面定義的方法和其他兩個類中的方法不一樣,我們要使它們必須用的是同樣的方法,不然就報錯

def fu(ob):     #這裏按照歸一化設計程序執行沒毛病
    ob.pay()
a1=Ali(100)
fu(a1)

a2=Wx(200)
a2.po()

抽象類,接口類

from abc import ABCMeta,abstractmethod      #引入模塊,這四行固定模式
class Payment(metaclass=ABCMeta):  # 抽象類(接口類):    #這裏的payment作為下面兩個類的父類,這個類名可以自己定義
    @abstractmethod
    def pay(self): pass  # 制定了一個規範   制定一個規範,下面類的方法必須使用這裏定義的這個方法,否則報錯,這個規範自己定義,所以函數名可以自己定義

class Ali(Payment):
    def __init__(self,money):
        self.money=money
    def pay(self):
        print(‘在支付寶上支付了%s元‘ % self.money)
class Jd(Payment):
    def __init__(self,money):
        self.money=money
    def pay(self):
        print(‘在京東上支付了%s‘ % self.money)

def fu(ob):
    ob.pay()

a1=Ali(100)
a2=Jd(200)
fu(a1)
fu(a2)
#這一版指定了規範,再像上一般那樣自己定義一個函數方法,單獨調用在這一版裏面就會報錯

# 封裝
# 廣義的封裝:實例化一個對象,給對象空降封裝一些屬性
# 狹義的封裝:私有制
# 私有成員:私有靜態字段  ,  私有方法,私有對象屬性 例:print(a1.__age)實例化對象不能訪問私有靜態字段,類名也不能
# 訪問私有靜態字段
# 對於私有靜態字段,類的外部不能訪問,類的內部可以訪問
# 只能在本類中內部訪問,類的外部,派生類均不可訪問


面試題:

class Parent:
    def __func(self):       #4,執行__func(self):
        print(‘in Parent func‘)     #5,執行__func(self):後打印的內容

    def __init__(self):     #2,父類這裏有__init__方法,執行__init__方法
        self.__func()       #3,__init__方法裏面執行了__func這個函數

class Son(Parent):
    def __func(self):
        print(‘in Son func‘)

son1 = Son()   #1,實例化一個對象,會自動執行本類中的__init__方法,但是Son這個類中沒有__init__方法,所以就去它的父類裏面找

多態:

# Python沒有多態,Python處處是多態,有鴨子類型
# 鴨子類型:函數每個類裏面的函數方法是一樣的   .  看著像鴨子類型,他就是鴨子
# 這些類 都互稱為鴨子

例:

class Str:
    def per(self):
        print(‘a‘)
class Int(Str):
    def per(self):
        print(‘b‘)
class List(Str):
    def per(self):
        print(‘c‘)
a1=Str()
a1.per()
#這些類,都互稱為鴨子

抽象類,接口類,封裝,多態