在OOP程序設計中,當我們定義一個class的時候,可以從某個現有的class繼承,新的class稱為子類(Subclass),而被繼承的class稱為基類、父類或超類(Base class、Super class)。
編寫一個名為 Animal 的class,有一個 run() 方法可以直接打印:
1 2 3 | >>>? class ?Animal( object ): ????? def ?run( self ): ?????????? print ( 'Animal?is?running...' ) |
當我們需要編寫Dog和Cat類時,就可以直接從Animal類繼承:
1 2 3 4 5 | >>>? class ?Dog(Animal): ????? pass >>>? class ?Cat(Animal): ????? pass |
對于Dog來說,Animal就是它的父類,對于Animal來說,Dog就是它的子類。cat和Dog類似。
集成有什么好處?最大的好處是子類獲得了父類的全部功能。由于Animal實現了run()方法,因此,Dog和Cat作為它的子類,什么事也沒干,就自動擁有了run()方法:
1 2 3 4 5 6 7 | >>>?dog? = ?Dog() >>>?dog.run() Animal? is ?running... >>>?cat? = ?Cat() >>>?cat.run() Animal? is ?running... |
也可以對子類增加一些方法,比如Dog類:
1 2 3 4 5 | >>>? class ?Dog(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
類改進如下:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 | >>>? class ?Dog(Animal): ????? def ?run( self ): ?????????? print ( 'Dog?is?running...' ) >>>? class ?Cat(Animal): ????? def ?run( self ): ?????????? print ( 'Cat?is?running...' ) >>>?dog = Dog() >>>?dog.run() Dog? is ?running... >>>?cat = Cat() >>>?cat.run() Cat? is ?running... |
當子類和父類都存在相同的run()方法時,我們說。子類的run()覆蓋了父類的run(),再代碼運行的時候,總是會調用子類的run()。這樣,我們就獲得了繼承的另一個好處:多態
要理解什么是多態,我們首先要對數據類型再作一點說明。當我們定義一個class的時候,我們實際上就定義了一種數據類型。我們定義的數據類型和Python自帶的數據類型,比如str、list、dict沒什么兩樣:
1 2 3 4 5 6 7 8 9 10 11 12 | >>>? isinstance (a, list ) True >>>? isinstance (b,Animal) True >>>? isinstance (c,Dog) True #再看一個: >>>? isinstance (c,Animal) True #看來c不僅僅是Dog,c還是Animal! |
因為Dog
是從Animal
繼承下來的,當我們創建了一個Dog
的實例c
時,我們認為c
的數據類型是Dog
沒錯,但c
同時也是Animal
也沒錯,Dog
本來就是Animal
的一種!
所以,在繼承關系中,如果一個實例的數據類型是某個子類,那它的數據類型也可以被看做是父類。但是,反過來就不行:
1 2 3 | >>>?b? = ?Animal() >>>? isinstance (b,Dog) False |
Dog
可以看成Animal
,但Animal
不可以看成Dog
。
要理解多態的好處,我們還需要再編寫一個函數,這個函數接受一個Animal
類型的變量:
1 2 3 4 5 6 7 8 9 10 11 12 13 | def ?run_twice(animal): ???? animal.run() ???? animal.run() >>>?run_twice(Animal()) Animal? is ?running... Animal? is ?running... >>>?run_twice(Dog()) Dog? is ?running... Dog? is ?running... >>>?run_twice(Cat()) Cat? is ?running... Cat? is ?running... |
看上去沒啥意思,但是仔細想想,現在,如果我們再定義一個Tortoise
類型,也從Animal
派生:
1 2 3 4 5 6 7 8 | 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()
等函數。
本文轉自 nw01f 51CTO博客,原文鏈接:http://blog.51cto.com/dearch/1764522,如需轉載請自行聯系原作者