java - 如何避免重复嵌套 switch 语句

Question

我们中的许多人都遇到过这样的情况，顶级 switch 语句似乎是一个很好的解决方案。仔细观察后，您开始认识到一些问题。

假设我们手动解析一个字符串，即逐个字符。为了简单起见，假设该字符串由拉丁字母的子集和其他内容(例如括号)组成。拉丁字符 ([abc]) 使我们的词法分析器执行非常相似的任务(但不是完全原始)，我们本能地想要对这些情况进行分组。从表面上看，有两种方法:

1)没有分组:代码重复。

case 'a':
  doOnA();
  break;
case 'b':
  doOnB();
  break;
case 'c':
  doOnC();
  break;
// Other cases
case '(':
  doOnOpening();
  break;
...

方法 doOnA、doOnB、doOnC 由于其复制粘贴性质而有些丑陋:

void doOnA() {
  // Do something specific to 'a'
  IntermediateResult ir = ...;
  // And then do something common
  ... // This code is copied to every method
}

为了减少复制粘贴的数量，可以通过以下方法对公共(public)行进行分组:

void thisCodeRepeatsInEveryMethodNow(IntermediateResult ir) {
  ...
}

然后我们希望 JVM 在某个时候内联它。

2) 分组:嵌套 switch 语句。

case 'a':
case 'b':
case 'c':
  doOnLatinLetter(c);
  break;
case '(':
  doOnOpening();
  break;
...

由于我们经常听说嵌套 switch 语句是邪恶的，因此我们引入了方法 doOnLatinLetter。

void doOnLatinLetter(char c) {
  IntermediateResult ir;
  switch (c) {
    case 'a':
      ir = ...;
      break;
    case 'b':
      ir = ...;
      break;
    case 'c':
      ir = ...;
      break;
  }

  // And then do something common
  ...
}

所以代价是现在我们必须检查 c 是否确实是“a”、“b”或“c”两次。但这是唯一的价格吗？

请注意，此方法doOnLatinLetter无助于避免任何代码重复(它在整个程序中只有一个调用)，因此它的“重构优点”很小(与移动静态内部类到新文件等)尽管如此，在这种情况下引入这样的方法是一个常见的建议。换句话说，代码看起来更漂亮。 我的猜测是，这种重构总是有支持者和反对者。

3)所以最终我归结为 IF 和 SWITCH block 的混合，如下所示:

if (c >= 'a' && c <='c') { // grouping by latin letters
  IntermediateResult ir;
  switch (c) {
    case 'a':
      ir = ...;
      break;
    case 'b':
      ir = ...;
      break;
    case 'c':
      ir = ...;
      break;
  }

  // And then do something common
  ...
} else { // everything else, that doesn't require grouping
  switch (c) {
    case '(':
    doOnOpening();
    break;
  ...
  }
}

如果从语义上讲我们必须将输入分成更多组，那么我们只需添加更多“else if”子句即可。

但我的问题是第二个和第三个解决方案仍然看起来像黑客。显然这里的多态也会让人感觉别扭。 Java 中有没有一种真正优雅的方法来解决这个问题？

Answer 1

您可以考虑为每个案例设置单独的处理程序，并使用继承来覆盖分组案例，并使用提供程序将它们收集在一起。例如(内部类只是为了简洁起见，我会将它们分解成现实世界中自己的文件)...

public class HandlerProvider implements IntConsumer {
    private final Map<Character, Handler> handlers = new HashMap<>();
    private final Handler defaultHandler = new NoOpHandler();

    public HandlerProvider() {
        register('a', new LetterAHandler());
        // Other case handlers ...
        register('(', new OpeningHandler());
    }

    public void register(char ch, Handler handler) {
        handlers.put(ch, handler);
    }

    public void accept(int value) {
        Character ch = (char) value;
        get(ch).accept(ch);
    }

    public Handler get(char ch) {
        return handlers.getOrDefault(ch, defaultHandler);
    }

    public interface Handler {
        void accept(char c);
    }

    public abstract class LetterHandler implements Handler {
        public void accept(char character) {
            IntermediateResult ir = getIntermediateResult(character);
            // And then do something common
        }
        public abstract IntermediateResult getIntermediateResult(int character);
    }

    public class LetterAHandler extends LetterHandler {
        public IntermediateResult getIntermediateResult(int character) {
            IntermediateResult ir = new IntermediateResult();
            // Do something specific to 'character'
            return ir;
        }
    }

    // Other case handlers ...

    public class OpeningHandler implements Handler {
        public void accept(char character) {
        }
    }

    // Default handler if no other matches are found... 
    // could have different behaviour such throw an error
    public class NoOpHandler implements Handler {
        public void accept(char character) {
        }
    }
}

然后您可以将字符作为流处理:

    HandlerProvider provider = new HandlerProvider();
    String input = ...;
    input.chars().forEachOrdered(provider);

或者单独每个字符

    for (char c : s.toCharArray()) {
       provider.get(c).accept(ch);        
    }

前面有点冗长，但更灵活，最终在很多情况下变得更容易维护。显然，您需要为 Handler 方法提供一个额外的参数，以便您的处理程序可以对任何输出进行操作，或者至少询问当前状态。但你已经了解了总体思路。