在枚举结构上循环时重构和删除 case 语句

Question

在自己的类中声明的枚举结构是业务逻辑类的成员变量。该枚举基本上代表了其他类的状态。

虽然我已经多次重新审视这个问题，但替换或删除这些案例陈述对我来说非常令人沮丧。

几个业务逻辑方法简单地迭代枚举并通过分配相同枚举的另一个值和其他属性来更改该类的状态。

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 语句都应该是一个通用接口的实现。但是如果我有 3 个方法迭代一个 4 成员枚举，这意味着我可能需要 3 个接口，每个接口有 4 个实现，给我 12 个类（加上 3 个接口）。那不会是类重载吗？这 3 种方法的逻辑运行良好，但问题在于重复的 switch/case 语句。

有没有办法重构这些 switch 语句，但又避免以多态的名义出现无数其他类？是否可以排除迭代枚举部分？还是只重构案例（逻辑所在）？

---

作为第一步，我完全删除了这些方法，让它们实现一个简单的接口：

public interface Command {
    void execute();
}

所以，它的操作方法实现了命令界面：

public class Operation1 implements Command {

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

    public void execute() {
        doOperation1();
    }

}

正如我所看到的，它会为我的业务逻辑类带来更简洁的效果，但 switch case 的痕迹会保留，对吧？

Answer 1

正如您可能从其他回复中猜到的那样，这是一个常见问题，已被 Martin Fowler 编入重构中。看看重构Replace Conditional with Polymorphism。 Joshua Kerievsky (Replace Conditional with Strategy) 也进行了类似的编码重构。

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

您可以在一个接口中包含所有三个方法，并对该接口有不同的实现（每个枚举一个），并让这个业务类委托调用..

同样为了改变状态，让操作的返回值是那个通用接口，以便在调用这些方法时，调用类可以为下一个状态返回适当的对象。