重构 if 语句以使用适当的模式

Question

我有一个包含一些状态的枚举：

enum State
{
    A,
    B,
    C,
    D
}

以及一个具有相应状态的对象：

class MyObject
{
    State state;
}

我需要编写一个算法，该算法采用两个 MyObject 实例并根据这些实例的特定状态执行某些操作：

void doWork(MyObject o1, MyObject o2)
{
     if (o1.state == A && o2.state == A)
     {
          // do something
     }
     else if (o1.state == A && o2.state == B)
     {}
     // etc for all combinations...

}

显然这种方法有很多问题，我想要更改它以理想地摆脱 if/else 语句。

这样的需求有什么模式吗？

谢谢

Answer 1

尽管我不确定它会好得多，但您可以做的是两个状态值的所有可能组合的某种矩阵；然后，您可以使用 o1.state 和 o2.state 作为该矩阵的索引。

您可以在该矩阵中存储不同的内容：

• 一个唯一值，您可以将其用作 switch 块的区分值，该块将替换您的 if .. else if .. else块——实际上并没有太大的改进。

或者你的矩阵可以包含...

• 命令对象。 （查找命令模式。）

如果你真的想摆脱if 语句，第二个选项可能是更好的一个；但请注意，您的代码将不再像 if/switch 块那样紧密地集中在一个位置，而是分布在多个不同的位置命令对象/类。

// forgive my syntax errors etc., my Java has definitely gone a little rusty!

interface WorkCommand {
    public abstract void run(MyObject o1, MyObject o2);
}

...

Map<Pair<State,State>, WorkCommand> commands;
// ^ pseudo-code type for your command look-up map; type Pair<X,Y> doesn't exist,
//   so replace this with something sensible!

void doWork(MyObject o1, MyObject o2)
{
    WorkCommand worker = commands.get(new Pair<State,State>(o1, o2));
    worker.run(o1, o2);
}

Answer 2

构建此结构的一种方法是，您可以在枚举中拥有一个抽象方法，每个元素都将实现该方法：

enum State
{
    A{
      public void void doSomeWork(State state){
        switch(state){
           case A:
           case B:
           ...
        }
      }
    },
    B,
    C,
    D

    abstract void doSomeWork(State state);
}

然后您的方法可以如下所示

void doWork(MyObject o1, MyObject o2){
   o1.state.doSomeWork(o2.state);
}

Answer 3

是的，它被称为...状态模式。重要的是只有一个状态可以定义行为，即您可能需要将 object1.state 和 object2.state 组合成元状态。使用 statecontext 注册此元状态，以便当 Myobject.state 更改时更新元状态。

interface MyObjectStates {
  void doWork(MyObject o1, MyObject o2);
}

class MyObjectStatesAA implements MyObjectStates {
  void doWork(MyObject o1, MyObject o2) {
    // do dowork for both states A
  }

class MyObjectStatesBB implements MyObjectStates {
  void doWork(MyObject o1, MyObject o2) {
    // do dowork for both states B
  }

// etc

然后，您需要在状态上下文中保存一个 MyObjectStates 对象，并在 MyObject.state 更改时更新它。您甚至可以完全删除状态枚举。如果您对这种方法感兴趣，请给我留言，如果您愿意，我会详细说明。

状态模式的优点是您不需要保存和读回枚举并相应地选择不同的代码路径，而是为您想要以不同方式处理的每个状态提供单独的代码。

Answer 4

我可能已经这样做了，它至少更具可读性

void doWork(MyObject o1, MyObject o2) {
    switch (o1.state) {
        case A: {
            switch (o2.state) {
                case A: {

                    break;
                }
                case B: {

                    break;
                }

            }
            break;
        }
    }
}

Answer 5

仅使用两种状态组合，嵌套开关可能是最快实现和理解的：

switch (o1.state) {
 case X: switch(o2.state) { }
 //..etc
}

如果案例顺序与某些组合无关，您可以交换 o1 和 o2 在这些情况下，然后将它们放入 switch （并避免重复的代码）。此外，对于具有相同行为的所有案例组合，您可以利用失败行为。

最后，以这种方式实现它可能会使这些组合的实际情况变得更加明显，这样您就可以实现更智能的方法。

Answer 6

面向对象的问题解决方案是状态模式。它涉及用状态对象封装状态交替条件。您可以在此处和此处。顺便说一句，如果您还没有这本书，我强烈建议您购买它。

干杯!