interruttore, custodia, predefinito

"Ciao, Amico!"

"Ciao, Bilaabo! Che bello rivederti. Solo le tue lezioni sono così belle e comprensibili. Non come questo Java Memory Model."

"Sì, Bilaabo sa come scegliere le lezioni. Oggi ti parlerò della dichiarazione di scambio."

"Penso che qualcuno me ne abbia già parlato."

"Ellie l'ha fatto. Quindi, Amigo non vuole sentire una lezione sull'affermazione di scambio? Forse inizierai a insegnare la tua?"

"No, voglio, voglio. Sentiamo la dichiarazione di scambio."

"OK. In Java, c'è qualcosa chiamato istruzione switch. È conveniente quando devi eseguire determinate azioni in base a vari valori di una variabile."

int i = 5;
switch(i)
{
 case 1:
  System.out.println("one");
  break;
 case 2:
  System.out.println("two");
  break;
 case 3:
  System.out.println("three");
  break;
 default:
  System.out.println("many");
}

int i = 5;
if (i == 1)
{
 System.out.println("one");
}
else if (i == 2)
{
 System.out.println("two");
}
else if (i == 3)
{
 System.out.println("three");
}
else
{
 System.out.println("many");
}

L' istruzione switch consente di saltare alla parte di codice desiderata se la variabile passata corrisponde al valore che segue la parola chiave case.

Se i è 1, l'esecuzione salterà alla riga contrassegnata con «caso 1».

Se i è 2, l'esecuzione salterà alla riga contrassegnata con «caso 2».

Se i è 3, l'esecuzione passerà alla riga contrassegnata con «caso 3».

"Se non c'è nessun salto in nessuno dei casi, viene eseguito il blocco «predefinito»."

"Capisco. E sulla destra c'è la stessa logica, ma implementata usando istruzioni if?"

"Sì."

"E che cos'è la parola 'break'? Hai detto che può essere usata solo in loop?"

"Sì, e qui. Quando viene eseguita l' istruzione break , usciamo immediatamente dallo switch ."

"Ma se l'istruzione break viene rimossa, tutte le righe all'interno dello switch verranno eseguite fino alla fine."

switch(i)
{
 case 1:
  System.out.println("one");
 case 2:
  System.out.println("two");
 case 3:
  System.out.println("three");
 default:
  System.out.println("many"); }

"In realtà, case è un'etichetta nel codice. Nell'istruzione switch, passiamo all'etichetta successiva e iniziamo a eseguire tutto il codice fino alla fine dello switch, o finché non incontriamo un'istruzione break."

"Quindi, se non scriviamo break, verrà eseguita la riga a cui saltiamo, seguita da tutte le altre righe fino alla parentesi graffa di chiusura. Giusto?"

"SÌ."

"Un gioco da ragazzi. Ma mi piace usare meglio le istruzioni if. Non hanno queste istruzioni break inutili."

"È vero che le istruzioni if ​​sono molto spesso più compatte. Ma un'istruzione switch a volte è più leggibile."

"Confrontare:"

public String getName(int i)
{
 switch(i)
 {
  case 1:
   return "one";
  case 2:
   return "two";
  case 3:
   return "three";
  default:
   return "many";
}

public String getName(int i)
{
 if (i == 1)
  return "one";

 if (i == 2)
  return "two";

 if (i == 3)
  return "three";

return "many"
}

"Non direi che è più leggibile."

"Va bene, ma che mi dici di questo esempio?"

public String getName(int i)
{
 switch(i)
 {
  case 1:
  case 2:
   return "one or two";
  case 3:
  case 4:
  case 5:
   return "three to five";
  default:
   return "many";
}

public String getName(int i)
{
 if (i == 1 || i == 2)
  return "one or two";

 if (i == 3 || i == 4 || i == 5)
  return "three to five";

return "many"
}

"Bilaabo, il tuo esempio non sembra corretto. Quindi, posso omettere l'istruzione break se uso return?"

"Esatto. Un'istruzione return uscirà immediatamente dal metodo."

"Sembra che le istruzioni if ​​siano sempre più compatte. Ma questa volta l'istruzione switch si è rivelata più leggibile."

"Uff, finalmente."

"Ancora una cosa. Non devi scrivere default alla fine. Se non lo fai, semplicemente non succederà nulla se nessuna delle etichette corrisponde."

"Uh, esatto. Come if-else, ma leggibile... molto più leggibile!"

"Fantastico. Sono contento che ti sia piaciuta la mia lezione."

"Oh, quasi dimenticavo. Inizialmente, potevi usare solo tipi ed enum primitivi nelle istruzioni switch. Ma ora hanno aggiunto il supporto per le stringhe."

"Vuoi dire che scrivo questo?"

public int getNumber(String number)
{
 switch(number)
 {
  case "one":
   return 1;
  case "two":
   return 2;
  case "three":
   return 3;
  default:
   return -1;
 }
}

"Sì. Comodo, vero?"

"Sì. Le dichiarazioni di scambio sono fantastiche!"