微信公眾號:碼農充電站pro
個人主頁:https://codeshellme.github.io
程式不是年輕的專利,但是,它屬於年輕。
目錄
我們已經知道封裝
,繼承
和多型
是物件導向的三大特徵,面嚮物件語言都會提供這些機制。
1,封裝
在這一節介紹類的私有屬性和方法
的時候,我們已經講到過封裝
。
封裝
就是在設計一個類的時候,只允許使用者訪問他需要的方法,將複雜的,沒有必要讓使用者知道的方法隱藏起來。這樣,使用者只需關注他需要的東西,為其遮蔽了複雜性。
私有性
就是實現封裝
的一種手段,這樣,類的設計者就可以控制類中的哪些屬性和方法可以被使用者訪問到。一般,類中的屬性,和一些複雜的方法都不會暴露給使用者。
由於前邊的章節介紹過封裝,這裡就不再舉例說明了。
2,繼承
通過繼承
的機制,可使得子類
輕鬆的擁有父類
中的屬性和方法
。繼承
也是一種程式碼複用
的方式。
Python 支援類的繼承,繼承的類
叫做子類
或者派生類
,被繼承的類
叫做父類
或基類
。
繼承的語法如下:
class 子類名(父類名):
pass
在子類名
後邊的括號中,寫入要繼承的父類。
object
類
在Python 的繼承體系中,object
是最頂層類,它是所有類的父類。在定義一個類時,如果沒有繼承任何類,會預設繼承object
類。如下兩種定義方式是等價的:
# 沒有顯示繼承任何類,預設繼承 object
class A1:
pass
# 顯示繼承 object
class A2(object):
pass
每個類中都有一個mro
方法,該方法可以列印類的繼承關係(順序)。我們來檢視A1
和 A2
的繼承關係:
>>> A1.mro()
[<class '__main__.A1'>, <class 'object'>]
>>>
>>> A2.mro()
[<class '__main__.A2'>, <class 'object'>]
可見這兩個類都繼承了 object
類。
繼承中的__init__
方法
當一個子類繼承一個父類時,如果子類中沒有定義__init__
,在建立子類的物件時,會呼叫父類的__init__
方法,如下:
#! /usr/bin/env python3
class A(object):
def __init__(self):
print('A.__init__')
class B(A):
pass
以上程式碼中,B
繼承了A
,A
中有__init__
方法,B
中沒有__init__
方法,建立類B
的物件b
:
>>> b = B()
A.__init__
可見A
中的__init__
被執行了。
方法覆蓋
如果類B
中也定義了__init__
方法,那麼,就只會執行B
中的__init__
方法,而不會執行A
中的__init__
方法:
#! /usr/bin/env python3
class A(object):
def __init__(self):
print('A.__init__')
class B(A):
def __init__(self):
print('B.__init__')
此時建立B
的物件b
:
>>> b = B()
B.__init__
可見,此時只執行了B
中的__init__
方法。這其實是方法覆蓋
的原因,因為子類
中的__init__
與父類
中的__init__
的引數列表一樣,此時,子類中的方法覆蓋了父類中的方法,所以建立物件b
時,只會執行B
中的__init__
方法。
當發生繼承關係(即一個子類繼承一個父類)時,如果子類中的一個方法與父類中的一個方法
一模一樣
(即方法名相同,引數列表也相同),這種情況就是方法覆蓋
(子類中的方法會覆蓋父類中的方法)。
方法過載
當方法名
與引數列表
都一樣時會發生方法覆蓋
;當方法名
一樣,引數列表
不一樣時,會發生方法過載
。
在單個類中,程式碼如下:
#! /usr/bin/env python3
class A(object):
def __init__(self):
print('A.__init__')
def test(self):
print('test...')
def test(self, i):
print('test... i:%s' % i)
類A
中的兩個test
方法,方法名
相同,引數列表
不同。
其實這種情況在Java
和 C++
是允許的,就是方法過載
。而在Python 中,雖然在類中這樣寫不會報錯,但實際上,下面的test(self, i)
已經把上面的test(self)
給覆蓋掉了。建立出來的物件只能呼叫test(self, i)
,而test(self)
是不存在的。
示例:
>>> a = A() # 建立 A 的物件 a
A.__init__
>>>
>>> a.test(123) # 可以呼叫 test(self, i) 方法
test... i:123
>>>
>>> a.test() # 呼叫 test(self) 發生異常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: test() missing 1 required positional argument: 'i'
在繼承關係中,程式碼如下:
#! /usr/bin/env python3
class A(object):
def __init__(self):
print('A.__init__')
def test(self):
print('test...')
class B(A):
def __init__(self):
print('B.__init__')
def test(self, i):
print('test... i:%s' % i)
上面程式碼中B
繼承了A
,B
和 A
中都有一個名為test
的方法,但是引數列表
不同。
這種情況跟在單個類中的情況是一樣的,在類B
中,test(self, i)
會覆蓋A 中的test(self)
,類B
的物件只能呼叫test(self, i)
,而不能呼叫test(self)
。
示例:
>>> b = B() # 建立 B 的物件
B.__init__
>>>
>>> b.test(123) # 可以呼叫 test(self, i) 方法
test... i:123
>>>
>>> b.test() # 呼叫 test(self) 方法,出現異常
Traceback (most recent call last):
File "<stdin>", line 1, in <module>
TypeError: test() missing 1 required positional argument: 'i'
super()
方法
super()
方法用於呼叫父類中的方法。
示例程式碼:
#! /usr/bin/env python3
class A(object):
def __init__(self):
print('A.__init__')
def test(self):
print('class_A test...')
class B(A):
def __init__(self):
print('B.__init__')
super().__init__() # 呼叫父類中的構造方法
def test(self, i):
print('class_B test... i:%s' % i)
super().test() # 呼叫父類中的 test 方法
演示:
>>> b = B() # 建立 B 的物件
B.__init__ # 呼叫 B 的構造方法
A.__init__ # 呼叫 A 的構造方法
>>>
>>> b.test(123) # 呼叫 B 中的 test 方法
class_B test... i:123
class_A test... # 執行 A 中的 test 方法
is-a
關係
一個子類的物件,同時也是一個父類的物件,這叫做is-a
關係。但是一個父類的物件,不一定是一個子類的物件。
這很好理解,就像,貓一定是動物,但動物不一定是貓。
我們可以使用isinstance()
函式來判斷一個物件是否是一個類的例項。
比如我們有如下兩個類,Cat
繼承了 Animal
:
#! /usr/bin/env python3
class Animal(object):
pass
class Cat(Animal):
pass
來看下物件和類之間的從屬關係:
>>> a = Animal() # 建立 Animal 的物件
>>> c = Cat() # 建立 Cat 的物件
>>>
>>> isinstance(a, Animal) # a 一定是 Animal 的例項
True
>>> isinstance(c, Cat) # c 一定是 Cat 的例項
True
>>>
>>> isinstance(c, Animal) # Cat 繼承了 Animal,所以 c 也是 Animal 的例項
True
>>> isinstance(a, Cat) # 但 a 不是 Cat 的例項
False
3,多繼承
多繼承
就是一個子類同時繼承多個父類,這樣,這個子類就同時擁有了多個父類的特性。
C++ 語言中允許多繼承,但由於多繼承會使得類的繼承關係變得複雜。因此,到了Java 中,就禁止了多繼承的方式,取而代之的是,在Java 中允許同時繼承多個介面
。
Python 中也允許多繼承,語法如下:
# 括號中可以寫多個父類
class 子類名(父類1, 父類2, ...):
pass
我們構造一個如下的繼承關係:
程式碼如下:
#! /usr/bin/env python3
class A(object):
def test(self):
print('class_A test...')
class B(A):
def test(self):
print('class_B test...')
class C(A):
def test(self):
print('class_C test...')
class D(B, C):
pass
類A
,B
,C
中都有test()
方法,D
中沒有test()
方法。
使用D
類中的mro()
方法檢視繼承關係:
>>> D.mro()
[<class 'Test.D'>, <class 'Test.B'>, <class 'Test.C'>, <class 'Test.A'>, <class 'object'>]
建立D
的物件:
>>> d = D()
如果類D
中有test()
方法,那麼d.test()
肯定會呼叫D
中的test()
方法,這種情況很簡單,不用多說。
當類D
中沒有test()
方法時,而它繼承的父類 B
和 C
中都有 test()
方法,此時會呼叫哪個test()
呢?
>>> d.test()
class_B test...
可以看到d.test()
呼叫了類B
中的 test()
方法。
實際上這種情況下,Python 直譯器會根據D.mro()
的輸出結果來依次查詢test()
方法,即查詢順序是D->B->C->A->object
。
所以d.test()
呼叫了類B
中的 test()
方法。
建議:
由於
多繼承
會使類的繼承關係變得複雜,所以並不提倡過多的使用多繼承
。
4,多型
多型
從字面上理解就是一個事物可以呈現多種狀態。繼承
是多型的基礎。
在上面的例子中,類D
的物件d
呼叫test()
方法時,沿著繼承鏈
(D.mro()
)查詢合適的test()
方法的過程,就是多型的表現過程。
比如,我們有以下幾個類:
Animal
:有一個speak()
方法Cat
:繼承Animal
類,有自己的speak()
方法Dog
:繼承Animal
類,有自己的speak()
方法Duck
:繼承Animal
類,有自己的speak()
方法
Cat
,Dog
,Duck
都屬於動物,因此都繼承Animal
,程式碼如下:
#! /usr/bin/env python3
class Animal(object):
def speak(self):
print('動物會說話...')
class Cat(Animal):
def speak(self):
print('喵喵...')
class Dog(Animal):
def speak(self):
print('汪汪...')
class Duck(Animal):
def speak(self):
print('嘎嘎...')
def animal_speak(animal):
animal.speak()
我們還定義了一個animal_speak
函式,它接受一個引數animal
,在函式內,呼叫了speak()
方法。
實際上,這種情況下,我們呼叫animal_speak
函式時,可以為它傳遞Animal
型別的物件,以及任何的Animal
子類的物件。
傳遞Animal
的物件時,呼叫了Animal
類中的 speak()
:
>>> animal_speak(Animal())
動物會說話...
傳遞Cat
的物件時,呼叫了Cat
類中的 speak()
:
>>> animal_speak(Cat())
喵喵...
傳遞Dog
的物件時,呼叫了Dog
類中的 speak()
:
>>> animal_speak(Dog())
汪汪...
傳遞Duck
的物件時,呼叫了Duck
類中的 speak()
:
>>> animal_speak(Duck())
嘎嘎...
可以看到,我們可以給animal_speak()
函式傳遞多種不同型別
的物件,為animal_speak()
函式傳遞不同型別的引數,輸出了不同的結果,這就是多型
。
5,鴨子型別
在靜態型別
語言中,有嚴格的型別判斷,上面的animal_speak()
函式的引數只能傳遞Animal
及其子類
的物件。
而Python 屬於動態型別
語言,不會進行嚴格的型別判斷。
因此,我們不僅可以為animal_speak()
函式傳遞Animal
及其子類
的物件,還可以傳遞其它與Animal
類毫不相關的類的物件,只要該類中有speak()
方法就行。
這種特性,在Python 中被叫做鴨子型別
,意思就是,只要一個事物走起來像鴨子,叫起來像鴨子,那麼它就是鴨子,即使它不是真正的鴨子
。
從程式碼上來說,只要一個類中有speak()
方法,那麼就可以將該類的物件傳遞給animal_speak()
函式。
比如,有一個鼓類Drum
,其中有一個函式speak()
:
class Drum(object):
def speak(self):
print('咚咚...')
那麼,類Drum
的物件也可以傳遞給animal_speak()
函式,即使Drum
與Animal
類毫不相關:
>>> animal_speak(Drum())
咚咚...
從另一個角度來考慮,實際上Python 函式中的引數,並沒有標明引數的型別。在animal_speak()
函式中,我們只是將引數叫做了animal
而已,因此我們就認為animal_speak()
函式應該接受Animal 類及其子類的物件,其實這僅僅只是我們認為的而已。
計算機並不知道animal
的含義,如果我們將原來的animal_speak()
函式:
def animal_speak(animal):
animal.speak()
改寫成:
def animal_speak(a):
a.speak()
實際上,我們知道,這兩個函式並沒有任何區別。因此,引數a
可以是任意的型別,只要a
中有speak()
方法就行。這就是Python 能夠表現出鴨子特性
的原因。
(完。)
推薦閱讀:
Python 簡明教程 --- 16,Python 高階函式
Python 簡明教程 --- 17,Python 模組與包
Python 簡明教程 --- 18,Python 物件導向
Python 簡明教程 --- 19,Python 類與物件
Python 簡明教程 --- 20,Python 類中的屬性與方法
歡迎關注作者公眾號,獲取更多技術乾貨。