Replace Conditional with Polymorphism (以多態取代條件表達式)

Summary： 你手上有個條件表達式，它根據對象類型的不一樣而選擇不一樣的行爲。將這個條件表達式的每一個分支放進一個子類內的覆寫函數中，而後將原始函數聲明爲抽象函數。

                                   

Motivation: 在面向對象術語中，聽上去最高貴的詞非「多態」莫屬。多態最根本的好處就是：若是你須要根據對象的不一樣類型而採起不一樣的行爲，多態使你沒必要編寫明顯的條件表達式。

正由於有了多態，因此你會發現：「類型碼的switch語句」以及「基於類型名稱的if-then-else語句」在面向對象程序中不多出現。

多態可以給你帶來不少好處。若是同一組條件表達式在程序許多地點出現，那麼使用多態的收益是最大的。使用條件表達式時，若是你想添加一種新類型，就必須查找並更新全部條件表達式。但若是改用多態，只需創建一個新的子類，並在其中提供適當的函數就好了。類的用戶不須要了解這個子類，這就大大下降了系統各部分之間的依賴，使系統升級更加容易。

Mechanics:

使用Replace Conditional with Polymorphism以前，首先必須由一個繼承結構。你可能已經經過先前的重構獲得了這一結構。若是尚未，如今就須要創建它。

要創建繼承結構，有兩種選擇：Replace Type Code with Subclasses和Replace Type Code with State/Strategy。前一種作法比較簡單，所以應該儘量使用它。但若是你須要在對象建立好了以後修改類型碼，就不能使用繼承手法，只能使用State/Strategy模式。此外，若是因爲其餘緣由，要重構的類已經有了子類，那麼也得使用State/Strategy。記住，若是若干switch語句針對的是同一個類型碼，你只需針對這個類型碼創建一個繼承結構就好了。

如今，能夠向條件表達式開戰了。你的目標多是switch語句，也多是if語句。

1.若是要處理的條件表達式是一個更大函數中的一部分，首先對條件表達式進行分析，而後使用Extract Method將它提煉到一個獨立函數去。

2.若是有必要，使用Move Method將條件表達式放置到繼承結構的頂端。

3.任選一個子類，在其中創建一個函數，使之覆寫超類中容納條件表達式的那個函數。將與該子類相關的條件表達式分支複製到新建函數中，並對它進行適當調整。

爲了順利進行這一步驟，你可能須要將超類中的某些private字段聲明爲protected。

4.編譯，測試。

5.在超類中刪掉條件表達式內被複制了的分支。

6.編譯，測試。

7.針對條件表達式的每一個分支，重複上述過程，直到全部分支都被移到子類內的函數爲止。

8.將超類之中容納條件表達式的函數聲明爲抽象函數。

   範例：

請容許我繼續使用「員工與薪資」這個簡單而又乏味的例子。咱們的類是從Replace Type Code with State/Strategy那個例子中拿來的，所以示意圖以下所示：

class Employee...
    int payAmount(){
        switch(getType()){
            case EmployeeType.ENGINEER:
                return _monthlySalary;
            case EmployeeType.SALESMAN:
                return _monthlySalary + _commission;
            case EmployeeType.MANAGER:
                return _monthlySalary + _bonus;
            default:
                throw new RuntimeException("Incorrect Employee");
        }
    }
    
    int getType(){
        return _type.getTypeCode();
    }
    private EmployeeType _type;
    
    abstract class EmployeeType...
        abstract int getTypeCode();
        
    class Engineer extends EmployeeType...
        int getTypeCode(){
            return Employee.ENGINEER;
        }
        
    ... and other subclasses

switch語句已經被很好地提煉出來，所以咱們沒必要費勁再作一遍。不過咱們須要將它移到EmployeeType類，由於EmployeeType纔是要被繼承的類。

class EmployeeType...
    int payAmount(Employee emp){
        switch (getTypeCode()){
            case ENGINEER:
                return emp.getMonthlySalary();
            case SALESMAN:
                return emp.getMonthlySalary() + emp.getCommission();
            case MANAGER:
                return emp.getMonthlySalary() + emp.getBonus();
            defaule:
                throw new RuntimeException("Incorrect Employee");
        }
    }

因爲咱們須要Employee的數據，因此須要將Employee對象做爲參數傳遞給payAmount()。這些數據中的一部分也許能夠移到EmployeeType來，但那時另外一項重構須要關心的問題了。

調整代碼，使之經過編譯，而後咱們修改Employee中的payAmount(）函數，令它委託EmployeeType：

class Employee...
    int payAmount(){
        return _type.payAmount(this);
    }

如今，咱們能夠處理switch語句了。這個過程有點象淘氣小男孩折磨一隻昆蟲--每次掰掉它一條腿。首先咱們把switch語句中的Engineer這一分支複製到Engineer類：

class Engineer...
    int payAmount(Employee emp){
        return emp.getMonthlySalary();
    }

這個新函數覆寫了超類中的switch語句內專門處理Engineer的分支。咱們能夠故意在case子句中放一個陷阱，檢查Engineer子類是否正常工做：

class EmployeeType...
    int payAmount(Employee emp){
        switch(getTypeCode()){
            case EmployeeType.ENGINEER:
                throw new RuntimeException("should be being overriden");
            case SALESMAN:
                return emp.getMonthlySalary() + emp.getCommission();
            case MANAGER:
                return emp.getMonthlySalary() + emp.getBonus();
            defaule:
                throw new RuntimeException("Incorrect Employee");
        }
    }

接下來咱們重複上述過程，直到全部分支都被去除爲止：

class Salesman...
    int payAmount(Employee emp){
        return emp.getMonthlySalary() + emp.getCommission();
    }
    
 class Manager...
     int payAmount(Employee emp){
         return emp.getMonthlySalary() + emp.getBonus();
     }

而後將超類的payAmount()函數聲明爲抽象函數：

class EmployeeType...
    abstract int payAmount(Employee emp);