时间戳

首页 > 解决方案 > 如何避免重复嵌套的 switch 语句

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

问题描述

我们中的许多人都遇到过这样的情况，顶级 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
}

为了减少复制粘贴公共行的数量，可以采用如下方法进行分组：

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 块的混合，如下所示：

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”子句。

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

标签： javaswitch-statement

解决方案

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

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 方法添加一个额外的参数，以便您的处理程序可以对输出的任何内容进行操作，或者至少询问当前状态。但你得到了一般的想法。

推荐阅读