Question

我们中的许多人遇到了这样的情况，其中顶级开关语句似乎是一个很好的解决方案。仔细观察，您开始发现一些问题。

假设我们手动解析一个字符串，即逐个字符。为了简单起见，假设字符串由拉丁字母的子集和其他字母（例如，括号）组成。拉丁字符（[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）分组：嵌套的开关语句。

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

由于我们经常听到嵌套的开关语句是邪恶的，因此我们介绍了 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”子句。

但是我的问题是第二和第三解决方案仍然看起来像黑客一样。显然，这里的多态性也会让人感到尴尬。 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方法添加一个额外的参数，以便您的处理程序可以对输出进行任何操作，或至少询问当前状态。但是您已经有了大致的想法。

Answer 2

这是特定于您的编码风格以及您的组织的风格。但是，我认为解决方案2和3的“混合”会让我失望。使用switch语句的原因通常是详尽无遗的-实际上，如果不是这种情况，许多IDE会警告您！

在您的示例中，此代码最简化的版本对我来说似乎是解决方案2）。但是，如果您经常需要检查字符是否为字母，请考虑创建辅助函数：

private boolean isLower(char c) {
    return c >= 'a' && c <= 'z';
}
private boolean isOpeningToken(char c) {
    return c == '(' || c == '{';
}

然后您应该能够执行一个简单的if .. else语句，该语句传达易于理解的语义，如下所示：

char c = ...;
if (isLower(c)) {
    // perform some letter-specific code
}
else if (isOpeningToken(c)) {
    // '(' or '{' -- you could use an if or an else statement 
    //               to distinguish between these tokens and 
    //               run appropriate handler
}
else {
    throw new Exception("Unhandled token!");
}

如何避免重复嵌套的切换语句

2 个答案: