La mia intenzione è quella di chiamare due casi all'interno di un altro caso nella stessa istruzione switch,Possiamo chiamare un "caso" all'interno di un altro caso nella stessa istruzione switch in Java?
switch (orderType) {
case 1:
statement 1;
break;
case 2:
statement 2;
break;
case 3:
**call case 1;**
**Call case 2;**
break;
default:
break;`
}
Possiamo farlo in Java?
Anche se non si può influenzare direttamente le switch casi, è possibile chiamare il metodo madre di passare da un caso e passare argomenti diversi . Ad esempio,
void foo(int param1, String param2, ...) {
switch (param1) {
case 0:
foo(1, "some string");
break;
case 1:
//do something
break;
default:
break;
}
}
No, non è possibile saltare allo snippet di codice in un altro caso di commutazione. Tuttavia, è possibile estrarre il codice in un metodo proprio che può essere chiamato da un altro caso:
switch (orderType) {
case 1:
someMethod1();
break;
case 2:
someMethod2();
break;
case 3:
someMethod1();
someMethod2();
break;
default:
break;
}
void someMethod1() { ... }
void someMethod2() { ... }
Non si può semplicemente chiamare un altro case blocco come questo. Che cosa si potrebbe fare, però, è avvolgere ognuno di questi blocchi in un metodo, per riutilizzarli:
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;
}
}
Come altri hanno sottolineato, è possibile implementare le valigie commutazione all'interno di un metodo che prende un parametro, che corrisponde al caso interruttore desiderato. Questi casi di commutazione possono chiamare ricorsivamente lo stesso metodo, con i casi di commutazione desiderati. Ecco un esempio pienamente funzionante che ti consente di verificare se un anno è bisestile o no:
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;
}
}
}
Non penso, perché vuoi farlo? –
L'utilizzo di "switch-case" ha lo scopo di rendere il codice più facile da capire, non cercare di complicarlo troppo. – Maroun
Rilevante [passaggio di un valore da un caso a un altro nell'istruzione switch] (http://stackoverflow.com/questions/16621708/passing-a-value-from-one-case-to-another-in-switch-statement) –