commutateur, cas, par défaut

« Salut Amigo ! »

"Salut, Bilaabo ! C'est si bon de vous revoir. Seuls vos cours sont si bons et compréhensibles. Pas comme ce modèle de mémoire Java."

"Oui, Bilaabo sait choisir ses cours. Aujourd'hui je vais vous parler de l'instruction switch."

"Je pense que quelqu'un m'en a déjà parlé."

"Ellie l'a fait. Donc, Amigo ne veut pas entendre une leçon sur l'instruction switch ? Peut-être que tu commenceras à enseigner la tienne ?"

"Non, je veux, je veux. Écoutons l'instruction switch."

"OK. En Java, il y a quelque chose qui s'appelle une instruction switch. C'est pratique lorsque vous devez effectuer certaines actions en fonction de diverses valeurs d'une variable."

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' instruction switch vous permet d'accéder directement au morceau de code souhaité si la variable qui lui est transmise correspond à la valeur qui suit la casse du mot clé.

Si i vaut 1, alors l'exécution sautera à la ligne marquée « cas 1 ».

Si i vaut 2, alors l'exécution sautera à la ligne marquée « cas 2 ».

Si i vaut 3, alors l'exécution sautera à la ligne marquée «cas 3».

"S'il n'y a pas de saut vers l'un des cas, alors le bloc "par défaut" est exécuté."

"Je vois. Et à droite, la même logique, mais implémentée à l'aide d'instructions if ?"

"Ouais."

"Et qu'est-ce que c'est que le mot 'break' ? Tu as dit qu'il ne pouvait être utilisé qu'en boucle ?"

"Oui, et ici. Lorsque l' instruction break est exécutée, nous quittons immédiatement le commutateur ."

"Mais si l'instruction break est supprimée, toutes les lignes à l'intérieur du commutateur seront exécutées jusqu'à la fin."

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

"En fait, case est une étiquette dans le code. Dans l'instruction switch, nous passons à l'étiquette suivante et commençons à exécuter tout le code jusqu'à la fin de l'interrupteur, ou jusqu'à ce que nous rencontrions une instruction break."

"Donc, si nous n'écrivons pas break, la ligne à laquelle nous sautons sera exécutée, suivie de toutes les autres lignes jusqu'à l'accolade fermante. C'est bien ça ?"

"Oui."

"C'est du gâteau. Mais j'aime mieux utiliser les instructions if. Ils n'ont pas ces instructions de pause inutiles."

"C'est vrai que les instructions if sont très souvent plus compactes. Mais une instruction switch est parfois plus lisible."

"Comparer:"

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

"Je ne dirais pas que c'est plus lisible."

« D'accord, mais qu'en est-il de cet exemple ?

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, votre exemple ne semble pas tout à fait correct. Alors, je peux omettre l'instruction break si j'utilise return?"

"C'est vrai. Une instruction return quittera immédiatement la méthode."

"Il semble que les instructions if soient toujours plus compactes. Mais l'instruction switch s'est avérée plus lisible cette fois."

"Ouf, enfin."

"Encore une chose. Vous n'êtes pas obligé d'écrire default à la fin. Si vous ne le faites pas, rien ne se passera simplement si aucune des étiquettes ne correspond."

"Euh, exactement. Comme si-autrement, mais lisible - beaucoup plus lisible!"

"Génial. Je suis content que tu aies aimé ma leçon."

"Oh, j'ai presque oublié. Au départ, vous ne pouviez utiliser que des types primitifs et des énumérations dans les instructions switch. Mais maintenant, ils ont ajouté la prise en charge des chaînes."

« Tu veux dire que j'écris ça ?

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

« Ouais. Pratique, non ?

"Oui. Les instructions Switch sont géniales !"