Java中嵌套开关语句的替代

Question

所以我今天写了一个方法，结合使用嵌套的switch语句，代码看起来相当干净简洁，但我被告知嵌套switch语句通常不是最好的方法因为他们可能会对添加的更多开关语句感到困惑。这里是什么样子我的代码示例：

EnumOne enumOne; 
EnumTwo enumTwo = null; 
EnumTwo enumThree = null; 

switch (enumOne) { 
    case CASE_ONE: 

     switch (enumTwo){ 
     case A: enumTwo = EnumTwo.B; break; 
     case C: enumTwo = EnumTwo.D; break; 
     default: break; 
     } 

     switch (enumThree) { 
     case AA: enumThree = EnumTwo.BB; break; 
     case CC: enumThree = EnumTwo.DD; break; 
     default: break; 
     } 

     break; 

    case CASE_TWO: 
    case CASE_THREE: 

     switch(EnumTwo) { 
     default: break; 
     } 

     switch (enumThree) { 
     case AA: enumThree = EnumTwo.XX; break; 
     case CC: enumThree = EnumTwo.YY; break; 
     default: break; 
     } 

     break; 

    default: 
     break; 
} 

所以我的问题是，从本质上讲，这将是一个合适的替代这些switch语句？

Answer 1

我建议你用一个调用来替换每个嵌套的switch语句，然后执行嵌套的switch代码。

写这样的事情，而不是：

EnumOne enumOne; 
    EnumTwo enumTwo = null; 
    EnumTwo enumThree = null; 

    switch (enumOne) 
    { 
     case CASE_ONE: 

      nested_switch1(); 

     case CASE_TWO: 
     case CASE_THREE: 

      nested_switch2(); 

      break; 

     default: 
      break; 
    } 

    nested_switch1() { 
      switch (enumTwo) 
      { 
      case A: 
       enumTwo = EnumTwo.B; 
       break; 
      case C: 
       enumTwo = EnumTwo.D; 
       break; 
      default: 
       break; 
      } 

      switch (enumThree) 
      { 
      case AA: 
       enumTwo = EnumTwo.BB; 
       break; 
      case CC: 
       enumTwo = EnumTwo.DD; 
       break; 
      default: 
       break; 
      } 

      break; 
    } 

nested_switch2() { 
      switch(EnumTwo) 
      { 
      default: 
       break; 
      } 

      switch (enumThree) 
      { 
      case AA: 
       enumTwo = EnumTwo.XX; 
       break; 
      case CC: 
       enumTwo = EnumTwo.YY; 
       break; 
      default: 
       break; 
      } 
} 

Answer 2

1. 由于使用大量的开关变得非常难读。
2. 和新的情况出现，然后任何时候，我们必须修改代码，并添加一个CASE

我们可以考虑在这种情况下

使用polymorphism我要举一个简单的类只是为了让你理解。 前面假设一类带开关的情况下

class Test 
{ 
    Animal a; 
    public Test(Animal a) 
    { 
     this.a=a; 
    } 

    public moveThisAnimal() 
    { 
     switch(this.a) 
     { 
      case fish: 
      System.out.println("swim"); 
      break; 

      case dog: 
      System.out.println("walk"); 
      break; 

      case bird: 
      System.out.println("fly"); 
      break; 
     } 
    } 
} 

现在我们替换这些开关与我们的多态性逻辑

Interface Animal 
{ 
    String move(); 
} 

Class Dog implements Animal 
{ 
    public String move() 
    { 
     return "walk"; 
    } 
} 


Class Bird implements Animal 
{ 
    public String move() 
    { 
     return "fly"; 
    } 
} 


Class Fish implements Animal 
{ 
    public String move() 
    { 
     return "swim"; 
    } 
} 

现在我们有Test类不带开关的情况下

class Test 
{ 
    Animal a; 
    public Test(Animal a) 
    { 
     this.a=a; 
    } 
    public moveThisAnimal() 
    { 
     System.out.println(this.a.move()); // all switch case statements removed 
    } 
} 

即使我们不得不添加进一步的案例，我们只需要添加实施没有改变这里

查看完整代码，看看是否有可能做

Answer 3

如果您有整数X和Y，并且您需要同时打开两者，则可以以某种明确方式组合它们并打开组合。例如，如果y < 10：

switch (x*10+y) 
{ 
case 0: // x == y == 0 
case 1: // x ==0, y == 1 
/// 
case 10: // x == 1, y == 0 
case 11: // x == y == 1 
// 
}