多型的實際含義是:同一個操作作用在不同物件上,可以產生不同的解釋與執行結果。也就是說,當你給不同物件送出同一個訊息時,它們會各自回應,回應方式卻不相同。
光從字面理解多型不太容易,我們先舉個例子。
主人養了兩隻動物,一隻鴨、一隻雞。當主人對它們下達「叫」的命令時,鴨會嘎嘎嘎地叫,雞則咯咯咯地叫。兩者同樣「都是動物、都會發出叫聲」,但依指令各自發出不同的聲音——這裡頭就藏著多型的思想。下面用程式碼具体說明。
1. 一段「多型」的 JavaScript 程式碼
把上面的故事寫成 JavaScript:
var makeSound = function( animal ){ if ( animal instanceof Duck ){ console.log( '嘎嘎嘎' ); }else if ( animal instanceof Chicken ){ console.log( '咯咯咯' ); } }; var Duck = function(){}; var Chicken = function(){}; makeSound( new Duck() ); //嘎嘎嘎 makeSound( new Chicken() ); //咯咯咯
這段程式碼確實體現了「多型」:分別向鴨與雞送出「叫喚」的訊息,它們各自做出不同反應。但這樣的多型並不令人滿意。若後來又添了一隻狗,叫聲是「汪汪汪」,你就必須回頭改動 makeSound 函式,狗才會叫。改程式碼總是危險的,改的地方越多、出錯機率越高;當動物種類越來越多,makeSound 極可能膨脹成一個巨大函式。
多型背後的核心思想,是把「做什麼」與「誰去做、怎麼做」分開,也就是把「不變的部分」與「可能變動的部分」隔離。在這個故事裡,動物都會叫是不變的,但不同種類的動物具體怎麼叫是可變的。把不變的隔離出來、把可變的封裝起來,程式就具備了擴充能力——相對於修改既有程式碼,只新增程式碼就能達到同樣功能,顯然優雅又安全得多,也符合開放封閉原則。
2. 物件的多型性
改寫後的程式碼,先把不變的部分隔離出來——所有動物都會發出叫聲:
var makeSound = function( animal ){ animal.sound(); };
再把可變的部分各自封裝。我們談的多型,指的就是物件的多型:
var Duck = function(){} Duck.prototype.sound = function(){ console.log( '嘎嘎嘎' ); }; var Chicken = function(){} Chicken.prototype.sound = function(){ console.log( '咯咯咯' ); }; makeSound( new Duck() ); //嘎嘎嘎 makeSound( new Chicken() ); //咯咯咯
現在向鴨與雞都送出「叫喚」,它們各自做出不同反應。哪天動物園裡多了一隻狗,只要追加幾行就好,不必動 makeSound:
var Dog = function(){} Dog.prototype.sound = function(){ console.log( '汪汪汪' ); }; makeSound( new Dog() ); //汪汪汪
3. 型別檢查與多型
型別檢查是表現物件多型之前繞不開的話題,但 JavaScript 是不必做型別檢查的動態型別語言。為了真正理解多型的目的,我們得繞個彎,從靜態型別語言說起。
靜態型別語言在編譯時會做型別匹配檢查。以 Java 為例,由於編譯階段有嚴格檢查,不能隨意賦予變數不同型別的值,這有時會讓程式碼顯得僵硬:
String str; str = abc; //沒有問題 str = 2; //報錯
試著把鴨子與雞叫的例子改寫成 Java:
public class Duck { //鴨子類 public void makeSound(){ System.out.println( 嘎嘎嘎 ); } } public class Chicken { //雞類 public void makeSound(){ System.out.println( 咯咯咯 ); } } public class AnimalSound { public void makeSound( Duck duck ){ //(1) duck.makeSound(); } } public class Test { public static void main( String args[] ){ AnimalSound animalSound = new AnimalSound(); Duck duck = new Duck(); animalSound.makeSound( duck ); //輸出:嘎嘎嘎 } }
鴨子已經能叫了,但現在想讓雞也叫,你會發現做不到——因為 (1) 處 AnimalSound 的 makeSound 被規定只能接受 Duck 型別的參數:
public class Test { public static void main( String args[] ){ AnimalSound animalSound = new AnimalSound(); Chicken chicken = new Chicken(); animalSound.makeSound( chicken ); //報錯,只能接受Duck類型的參數 } }
享受靜態語言型別檢查帶來的安全感之餘,我們偶爾也會覺得手腳被束縛。
為了解決這件事,靜態型別的物件導向語言通常設計為可以「向上轉型」:替類別變數賦值時,型別既可以是該類本身,也可以是它的超類。這就像描述天上的麻雀或喜鵲時,我們通常說「一隻麻雀在飛」或「一隻喜鵲在飛」,但若想忽略具體種類,也可以說「一隻鳥在飛」。
同理,當 Duck 與 Chicken 的型別都隱藏在超型別 Animal 背後,兩者就能被交換使用——這是讓物件表現出多型的必經之路,而多型正是實作眾多設計模式的目標。
4. 用繼承取得多型效果
繼承是讓物件表現多型最常用的手段,通常分為實作繼承與介面繼承。這裡先談實作繼承,介面繼承的範例請參閱第 21 章。
先建立一個 Animal 抽象類,再讓 Duck 與 Chicken 都繼承它。下列程式碼中 (1)、(2) 兩行的賦值顯然成立,因為鴨子與雞也是動物:
public abstract class Animal { abstract void makeSound(); //抽象方法 } public class Chicken extends Animal{ public void makeSound(){ System.out.println( 咯咯咯 ); } } public class Duck extends Animal{ public void makeSound(){ System.out.println( 嘎嘎嘎 ); } } Animal duck = new Duck(); //(1) Animal chicken = new Chicken(); //(2)
剩下的就是讓 AnimalSound 的 makeSound 接受 Animal 型別,而不是具體的 Duck 或 Chicken:
public class AnimalSound{ public void makeSound( Animal animal ){ //接受Animal類型的參數 animal.makeSound(); } } public class Test { public static void main( String args[] ){ AnimalSound animalSound= new AnimalSound (); Animal duck = new Duck(); Animal chicken = new Chicken(); animalSound.makeSound( duck ); //輸出嘎嘎嘎 animalSound.makeSound( chicken ); //輸出咯咯咯 } }
5. JavaScript 的多型
前面的說明讓我們知道,多型的思想是把「做什麼」與「誰去做」分開,而要做到這件事,根本前提是先消除型別之間的耦合。若耦合沒有解除,你在 makeSound 裡指定了發叫聲的物件屬於某個型別,它就無法被替換成另一個型別。Java 靠向上轉型來達成,而 JavaScript 的變數型別在執行期是可變的:同一個物件既能表示 Duck,也能表示 Chicken,這意味著 JavaScript 物件的多型性與生俱來。
原因不難解釋:作為動態型別語言,JavaScript 在編譯時沒有型別檢查流程,既不檢查建立的物件型別,也不檢查傳遞的參數型別。所以你可以往 makeSound 裡傳 duck,也可以傳 chicken。
也就是說,某種動物能不能叫,取決於它有沒有 makeSound 方法,而不取決於它是哪一類的物件,這裡不存在任何程度的「型別耦合」。在 JavaScript 中,你不需要向上轉型之類的技巧就能取得多型效果。
6. 多型在物件導向設計中的作用
不少人認為多型是物件導向語言中最重要的技術。但我們目前還不容易看出這一點——畢竟大多數人並不關心雞怎麼叫、鴨怎麼叫。讓雞和鴨在同一個訊息下發出不同叫聲,跟程式設計師又有什麼關係?
Martin Fowler 在《重構:改善既有程式的設計》裡寫道:
多型最根本的好處在於,你不必再向物件詢問「你是什麼型別」然後依答案呼叫某個行為——你只管呼叫該行為,其餘的一切多型機制都會替你安排妥當。
換句話說,多型最根本的作用,就是把程序化的條件分支語句轉換成物件的多型,從而消除這些條件分支。
Fowler 的話可以用下面這個例子詮釋:
在電影拍攝現場,當導演喊出「action」,主角開始背台詞,燈光師負責打光,後面的臨演假裝中槍倒地,道具師往鏡頭裡灑雪花。收到同一個訊息時,每個物件都知道自己該做什麼。若不利用物件的多型,而用程序導向的方式來寫這段邏輯,那就相當於電影開拍之後,導演每次都得走到每個人面前,先確認他的職業分工(型別),再告訴他要做什麼——對應到程式裡,就是充斥著條件分支語句。
善用多型,導演發布訊息時就不必操心各物件接到訊息後要做什麼。物件該做什麼不是臨時決定的,而是事先約定並排練好的;每個物件該做的事,已經成為它的方法,安裝在物件內部。所以這些物件能依同一個訊息,有條不紊地各自工作。
把行為分散到各個物件中,讓它們各自負責自己的行為,這正是物件導向設計的優點。
再看一個實務上常見的例子,思想跟動物叫聲的故事幾乎一樣。
假設我們要寫一個地圖應用,有兩家 API 服務商可選。目前採用 Google 地圖,它的 API 提供 show 方法負責在頁面上渲染地圖:
var googleMap = { show: function(){ console.log( '開始渲染google地圖' ); } }; var renderMap = function(){ googleMap.show(); }; renderMap(); // 輸出: 開始渲染google地圖
後來因為某些原因要換成百度地圖,為了讓 renderMap 保持一定彈性,我們用條件分支讓它同時支援兩家:
var googleMap = { show: function(){ console.log( '開始渲染google地圖' ); } }; var baiduMap = { show: function(){ console.log( '開始渲染baidu地圖' ); } }; var renderMap = function( type ){ if ( type === 'google' ){ googleMap.show(); }else if ( type === 'baidu' ){ baiduMap.show(); } }; renderMap( 'google' ); // 輸出: 開始渲染google地圖 renderMap( 'baidu' ); // 輸出: 開始渲染baidu地圖
renderMap 目前確實有了彈性,但這種彈性很脆弱:一旦要換成搜搜地圖,還是得改 renderMap,繼續往裡頭堆條件分支。
先把程式中相同的部分抽象出來,也就是「顯示某個地圖」:
var renderMap = function( map ){ if ( map.show instanceof Function ){ map.show(); } }; renderMap( googleMap ); // 輸出: 開始渲染google地圖 renderMap( baiduMap ); // 輸出: 開始渲染baidu地圖
多型在哪裡?當我們分別向 Google 地圖與百度地圖物件送出「展示地圖」的訊息時,各自呼叫它們的 show 方法,產生不同結果。物件的多型提醒我們:「做什麼」與「怎麼做」是可以分開的。即使日後加上搜搜地圖,renderMap 依然不必更動:
var sosoMap = { show: function(){ console.log( '開始渲染soso地圖' ); } }; renderMap( sosoMap ); // 輸出: 開始渲染soso地圖
這裡我們假設每家地圖 API 展示地圖的方法名都叫 show。實務上未必這麼順利,此時可以借助「適配器模式」來解決。
以上就是本文的全部內容,用比較生活化的例子說明多型,希望大家真的有所收穫。