comutator, caz, implicit

"Bună, Amigo!"

"Bună, Bilaabo! Mă bucur să te revăd. Doar prelegerile tale sunt atât de bune și de înțeles. Nu ca acest model de memorie Java."

"Da, Bilaabo știe cum să aleagă lecțiile. Azi o să vă povestesc despre declarația switch."

— Cred că cineva mi-a spus deja despre asta.

"Ellie a făcut-o. Deci, Amigo nu vrea să audă o lecție despre declarația de comutare? Poate vei începe să predai propriul tău?"

"Nu, vreau, vreau. Să auzim despre declarația de comutare."

"OK. În Java, există ceva numit o instrucțiune switch. Este convenabil atunci când trebuie să efectuați anumite acțiuni în funcție de diferitele valori ale unei 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");
}

Instrucțiunea switch vă permite să săriți la fragmentul de cod dorit dacă variabila transmisă acesteia se potrivește cu valoarea care urmează cuvântului cheie caz.

Dacă i este 1, atunci execuția va sări la linia marcată „cazul 1”.

Dacă i este 2, atunci execuția va sări la linia marcată „cazul 2”.

Dacă i este 3, atunci execuția va sări la linia marcată „cazul 3”.

„Dacă nu există niciun salt la niciunul dintre cazuri, atunci blocul „implicit” este executat.”

"Înțeleg. Și în dreapta este aceeași logică, dar implementată folosind instrucțiuni if?"

"Da."

„Și ce este cu cuvântul „break”? Ai spus că poate fi folosit doar în bucle?”

"Da, și aici. Când instrucțiunea break este executată, ieșim imediat din comutator ."

„Dar dacă instrucțiunea break este eliminată, atunci toate liniile din interiorul comutatorului vor fi executate până la sfârșit.”

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"); }

"De fapt, case este o etichetă în cod. În instrucțiunea switch, sărim la următoarea etichetă și începem să executăm tot codul până la sfârșitul comutației sau până când întâlnim o instrucțiune break."

„Deci, dacă nu scriem pauză, atunci linia la care sărim va fi executată, urmată de toate celelalte rânduri până la acolada de închidere. Este corect?”

"Da."

"O bucată de tort. Dar îmi place să folosesc mai bine declarațiile if. Nu au aceste afirmații break inutile."

"Este adevărat că declarațiile if sunt foarte adesea mai compacte. Dar o declarație switch este uneori mai lizibilă."

"Comparaţie:"

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"
}

„Nu aș spune că este mai lizibil”.

— Bine, dar cum rămâne cu acest exemplu?

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, exemplul tău nu pare corect. Deci, pot omite declarația break dacă folosesc return?"

"Așa este. O declarație return va ieși imediat din metodă."

"Se pare că declarațiile if sunt întotdeauna mai compacte. Dar declarația switch s-a dovedit a fi mai lizibilă de data aceasta."

— Pf, în sfârşit.

"Încă un lucru. Nu trebuie să scrieți implicit la sfârșit. Dacă nu o faceți, atunci pur și simplu nu se va întâmpla nimic dacă niciuna dintre etichete nu se potrivește."

„Uh, exact. Ca dacă-altfel, dar lizibil – mult mai lizibil!”

— Minunat. Mă bucur că ți-a plăcut lecția mea.

"Oh, aproape că am uitat. Inițial, puteai folosi doar tipuri și enumări primitive în declarațiile switch. Dar acum au adăugat suport pentru Strings."

— Vrei să spui că scriu asta?

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

— Da. Convenabil, nu?

"Da. Declarațiile Switch sunt grozave!"