Können wir einen "Fall" in einem anderen Fall in der gleichen Switch-Anweisung in Java aufrufen?

Question

Meine Absicht ist es zwei Fälle, in einem anderen Fall in der gleichen switch-Anweisung zu nennen,

switch (orderType) { 
     case 1: 
      statement 1; 
      break; 
     case 2: 
      statement 2; 
      break; 
     case 3: 
      **call case 1;** 
      **Call case 2;** 
      break; 
     default: 
      break;` 
} 

Können wir das in Java?

Answer 1

Obwohl Sie nicht die switch Fällen direkt beeinflussen können, können Sie Switch-Mutter Methode von einem Fall rufen und verschiedene Argumente übergeben . Zum Beispiel

void foo(int param1, String param2, ...) { 
    switch (param1) { 
     case 0: 
      foo(1, "some string"); 
      break; 

     case 1: 
      //do something 
      break; 

     default: 
      break; 
    } 
} 

Answer 2

Nein, Sie können nicht springen zum Code-Schnipsel in einem anderen Schalter Fall. Sie können jedoch den Code in eine eigene Methode extrahieren, die von einem anderen Fall aufgerufen werden kann:

switch (orderType) { 
    case 1: 
     someMethod1(); 
     break; 
    case 2: 
     someMethod2(); 
     break; 
    case 3: 
     someMethod1(); 
     someMethod2(); 
     break; 
    default: 
     break; 
} 

void someMethod1() { ... } 
void someMethod2() { ... } 

Answer 3

Sie können nicht nur eine andere case Block wie folgt aufrufen. Was Sie tun können, ist aber in einem Verfahren jeder dieser Blöcke wickeln und wieder zu verwenden:

private void doSomething() { 
    // implementation 
} 

private void doSomethingElse() { 
    // implementation 
} 

private void runSwitch(int order) { 

    switch (orderType) { 
      case 1: 
       doSomething(); 
       break; 
      case 2: 
       doSomethingElse(); 
       break; 
      case 3: 
       doSomething(); 
       doSomethingElse(); 
       break; 
      default: 
       break; 
    } 
} 

Answer 4

Wie andere haben darauf hingewiesen, können Sie Ihren Switch Fälle innerhalb einer Methode implementieren, die einen Parameter annimmt, die auf die gewünschte Schaltergehäuse entspricht. Diese Switch-Fälle können rekursiv dieselbe Methode mit den gewünschten Switch-Fällen aufrufen. Hier ist ein voll funktionsfähiges Beispiel, mit dem Sie überprüfen können, ob ein Jahr ein Schaltjahr ist oder nicht:

public class LeapYear { 

    static int year = 2016; 

    public static void main(String[] args) { 

     leapSwitch(1); 

    } 

    public static void leapSwitch(int switchcase) { 

     switch (switchcase) { 

     case 1: { 
      if (year % 4 == 0) { 
       leapSwitch(2); 
      } else { 
       leapSwitch(5); 
      } 
     } 
      break; 

     case 2: { 
      if (year % 100 == 0) { 
       leapSwitch(3); 

      } else { 
       leapSwitch(4); 
      } 
     } 
      break; 

     case 3: { 
      if (year % 400 == 0) { 
       leapSwitch(4); 

      } else { 
       leapSwitch(5); 
      } 
     } 
      break; 

     case 4: { 
      System.out.println(year+ " is a leap year!"); 
     } 
      break; 

     case 5: { 
      System.out.println("Not a leap year..."); 
     } 
      break; 

     } 
    } 
}