python:繼承和多態
繼承和多態
在OOP程序設計中,當我們定義一個class的時候,可以從某個現有的class繼承,新的class稱為子類(Subclass),而被繼承的class稱為基類、父類或超類(Base class、Super class)。
比如,我們已經編寫了一個名為Animal
的class,有一個run()
方法可以直接打印:
class Animal(object): def run(self): print(‘Animal is running...‘)
當我們需要編寫Dog
和Cat
類時,就可以直接從Animal
類繼承:
class Dog(Animal):pass class Cat(Animal): pass
對於Dog
來說,Animal
就是它的父類,對於Animal
來說,Dog
就是它的子類。Cat
和Dog
類似。
繼承有什麽好處?最大的好處是子類獲得了父類的全部功能。由於Animial
實現了run()
方法,因此,Dog
和Cat
作為它的子類,什麽事也沒幹,就自動擁有了run()
方法:
dog = Dog() dog.run() cat = Cat() cat.run()
運行結果如下:
Animal is running... Animal is running...
當然,也可以對子類增加一些方法,比如Dog類:
classDog(Animal): def run(self): print(‘Dog is running...‘) def eat(self): print(‘Eating meat...‘)
繼承的第二個好處需要我們對代碼做一點改進。你看到了,無論是Dog
還是Cat
,它們run()
的時候,顯示的都是Animal is running...
,符合邏輯的做法是分別顯示Dog is running...
和Cat is running...
,因此,對Dog
和Cat
類改進如下:
class Dog(Animal): def run(self):print(‘Dog is running...‘) class Cat(Animal): def run(self): print(‘Cat is running...‘)
再次運行,結果如下:
Dog is running... Cat is running...
多態:當子類和父類都存在相同的run()
方法時,我們說,子類的run()
覆蓋了父類的run()
,在代碼運行的時候,總是會調用子類的run()
。這樣,我們就獲得了繼承的另一個好處:多態。
要理解什麽是多態,我們首先要對數據類型再作一點說明。當我們定義一個class的時候,我們實際上就定義了一種數據類型。我們定義的數據類型和Python自帶的數據類型,比如str、list、dict沒什麽兩樣:
a = list() # a是list類型 b = Animal() # b是Animal類型 c = Dog() # c是Dog類型
判斷一個變量是否是某個類型可以用isinstance()
判斷:
>>> isinstance(a, list) True >>> isinstance(b, Animal) True >>> isinstance(c, Dog) True
看來a
、b
、c
確實對應著list
、Animal
、Dog
這3種類型。
但是等等,試試:
>>> isinstance(c, Animal)
True
看來c
不僅僅是Dog
,c
還是Animal
!
不過仔細想想,這是有道理的,因為Dog
是從Animal
繼承下來的,當我們創建了一個Dog
的實例c
時,我們認為c
的數據類型是Dog
沒錯,但c
同時也是Animal
也沒錯,Dog
本來就是Animal
的一種!
所以,在繼承關系中,如果一個實例的數據類型是某個子類,那它的數據類型也可以被看做是父類。但是,反過來就不行:
>>> b = Animal() >>> isinstance(b, Dog) False
Dog
可以看成Animal
,但Animal
不可以看成Dog
。
要理解多態的好處,我們還需要再編寫一個函數,這個函數接受一個Animal
類型的變量:
def run_twice(animal): animal.run() animal.run()
當我們傳入Animal
的實例時,run_twice()
就打印出:
>>> run_twice(Animal()) Animal is running... Animal is running...
當我們傳入Dog
的實例時,run_twice()
就打印出:
>>> run_twice(Dog()) Dog is running... Dog is running...
當我們傳入Cat
的實例時,run_twice()
就打印出:
>>> run_twice(Cat()) Cat is running... Cat is running...
看上去沒啥意思,但是仔細想想,現在,如果我們再定義一個Tortoise
類型,也從Animal
派生:
class Tortoise(Animal): def run(self): print(‘Tortoise is running slowly...‘)
當我們調用run_twice()
時,傳入Tortoise
的實例:
>>> run_twice(Tortoise()) Tortoise is running slowly... Tortoise is running slowly...
你會發現,新增一個Animal
的子類,不必對run_twice()
做任何修改,實際上,任何依賴Animal
作為參數的函數或者方法都可以不加修改地正常運行,原因就在於多態。
多態的好處就是,當我們需要傳入Dog
、Cat
、Tortoise
……時,我們只需要接收Animal
類型就可以了,因為Dog
、Cat
、Tortoise
……都是Animal
類型,然後,按照Animal
類型進行操作即可。由於Animal
類型有run()
方法,因此,傳入的任意類型,只要是Animal
類或者子類,就會自動調用實際類型的run()
方法,這就是多態的意思:
對於一個變量,我們只需要知道它是Animal
類型,無需確切地知道它的子類型,就可以放心地調用run()
方法,而具體調用的run()
方法是作用在Animal
、Dog
、Cat
還是Tortoise
對象上,由運行時該對象的確切類型決定,這就是多態真正的威力:調用方只管調用,不管細節,而當我們新增一種Animal
的子類時,只要確保run()
方法編寫正確,不用管原來的代碼是如何調用的。這就是著名的“開閉”原則:
對擴展開放:允許新增Animal
子類;
對修改封閉:不需要修改依賴Animal
類型的run_twice()
等函數。
繼承還可以一級一級地繼承下來,就好比從爺爺到爸爸、再到兒子這樣的關系。而任何類,最終都可以追溯到根類object,這些繼承關系看上去就像一顆倒著的樹。比如如下的繼承樹:
┌───────────────┐
│ object │
└───────────────┘
│
┌────────────┴────────────┐
│ │
▼ ▼
┌─────────────┐ ┌─────────────┐
│ Animal │ │ Plant │
└─────────────┘ └─────────────┘
│ │
┌─────┴──────┐ ┌─────┴──────┐
│ │ │ │
▼ ▼ ▼ ▼
┌─────────┐ ┌─────────┐ ┌─────────┐ ┌─────────┐
│ Dog │ │ Cat │ │ Tree │ │ Flower │
└─────────┘ └─────────┘ └─────────┘ └─────────┘
python:繼承和多態