在枚舉結構上盤旋時重構和刪除case語句

Question

在其自己的類中聲明的枚舉結構是業務邏輯類的成員變量。那個枚舉基本上代表了另一個類的狀態。

雖然我重新審視這個問題好幾次，替換或刪除那些case語句被證明相當令人沮喪的我。

幾個業務邏輯方法簡單遍歷枚舉和通過分配相同的枚舉的另一個值改變類的狀態下，和其它性質。

public enum MyEnum{ A,B,C,D } 

業務邏輯類有該枚舉作爲成員：

public class BusinessLogic { 

    private MyEnum CurrentSelection; 
    private int propertyX; 
    private int propertyY; 

    public void operation1(){ 
     switch(CurrentSelection){ 
     case A: {alter propertyX this way; break;} 
     case B: {alter propertyY this way; break;} 
     case C: {alter propertyX that way; break;} 
     case D: {alter propertyY that way; break;} 
     } 

    } 

    public void operation2(){ 
     switch(CurrentSelection){ 
     case A: {CurrentSelection=MyEnum.B; break;} 
     case B: {CurrentSelection=MyEnum.C; break;} 
     ....etc 
     } 
    } 

    public void operation3(){ 
     switch(CurrentSelection){ 
     case A: {CurrentSelection=MyEnum.D; break;} 
     case B: {CurrentSelection=MyEnum.A; break;} 
     ....etc 
     } 
    } 
} 

另一個客戶端類將實例業務邏輯的類，草簽它的屬性，然後使用它的操作方法。

我已經成功做了什麼（從SO幫助）是封裝的操作方法到命令模式結構，這樣我就可以調用的操作沒有任何case語句。 （here）。

我想我的麻煩是如何在我的業務邏輯類中封裝case語句。我懷疑我需要多態性和適當的數據結構。

重構專家建議每個case語句應該是一個通用接口的實現。但是，如果我有3個方法遍歷4個成員的枚舉，這意味着我可能需要3個接口和4個實現，給我12個類（加上3個接口）。這不是一個超負荷的類嗎？這3種方法的邏輯工作正常，但問題在於重複開關/情況聲明。

有沒有一種方法來重構這些switch語句，但避免多態性名其他類無數？是否可以將迭代遍歷枚舉部分分解出來？或者只是案例（其中的邏輯是）應該被重構？

---

作爲第一步予除去那些方法完全我具有它們執行一個簡單的接口：

public interface Command { 
    void execute(); 
} 

所以，其操作方法實現的命令接口：

public class Operation1 implements Command { 

    private void doOperation1(){ 
     switch(CurrentSelection){ 
      ..all the cases here 
     }  
    } 

    public void execute() { 
     doOperation1(); 
    } 

} 

正如我看到這一點，它會買我一個更清潔的商業邏輯課程，但切換案例的痕跡將保持不變，對吧？

Answer 1

你可能包括一個接口的所有三種方法，並有一個接口（每個枚舉）的不同的實現，並有該樓內設有商務類代表的電話..

也改變了狀態，有回報來自操作的值是該通用接口，以便在調用這些方法時，調用類可以爲下一個狀態返回適當的對象。

Answer 2

要闡述我的意見，並逐漸接近，我認爲RMN在談論，你可以做到以下幾點：

public interface MyInterface { 
    operation1(property); 
    operation2(property); 
    operation3(property); 
} 

public enum MyEnum implements MyInterface { 
    A { 
     operation1(property) { 
      //Do Stuff 
     } 
     operation2(property) { 
      //Do Stuff 
     } 
     operation3(property) { 
      //Do Stuff 
     } 
    }, 
    B { 
     operation1(property) { 
      //Do Stuff 
     } 
     operation2(property) { 
      //Do Stuff 
     } 
     operation3(property) { 
      //Do Stuff 
     } 
    }, 
    C { 
     operation1(property) { 
      //Do Stuff 
     } 
     operation2(property) { 
      //Do Stuff 
     } 
     operation3(property) { 
      //Do Stuff 
     } 
    }, 
    D { 
     operation1(property) { 
      //Do Stuff 
     } 
     operation2(property) { 
      //Do Stuff 
     } 
     operation3(property) { 
      //Do Stuff 
     } 
    } 
} 

這就讓你有一個命令模式 - 即的東西做的工作爲你選擇不同的元素。它也類似於狀態模式，儘管這裏的重點在於執行而不是數據或數據狀態。

希望這會有所幫助。

Answer 3

正如您可能從其他答案中猜到的那樣，這是一個常見問題，並已被編碼爲Martin Fowler的重構。看看重構Replace Conditional with Polymorphism。 Joshua Kerievsky也有類似的編碼重構（Replace Conditional with Strategy）。