Java >> Tutoriel Java >  >> Tag >> switch

Switch-Case en Java

Ce didacticiel vous guidera sur l'utilisation de la casse dans les programmes Java. Il s'agit d'une instruction multi-branches qui permet d'exécuter différents morceaux de code en fonction du résultat d'une expression.

Le commutateur peut accepter une valeur de type int, byte, char ou short. À partir de JDK7, il a même commencé à autoriser les Enums, les Strings et les objets des classes Wrapper.

Bases de Switch-case en Java

Le didacticiel comporte les sections suivantes pour vous aider à apprendre rapidement.

Déroulement du programme

Chaque fois que vous écrivez un morceau de code, le compilateur doit le convertir en bytecode et vous donner ensuite la sortie souhaitée. Le flux d'un programme représente l'ordre d'exécution des instructions sous-jacentes.

Il existe principalement trois types de flux dans un programme :

Séquentiel :

Le déroulement séquentiel d'un programme est le déroulement normal. Cela signifie que la ligne 1 s'exécute en premier, puis la ligne 2, la ligne 3, etc. jusqu'à ce que le contrôle atteigne la fin de votre code.

Conditionnel :

Le flux conditionnel du programme se produit lorsqu'une partie spécifique du code s'exécute en laissant de côté une autre partie. Cela signifie que la partie à exécuter dépend du résultat des instructions conditionnelles.

Java prend en charge deux instructions conditionnelles :if-else et Switch-Case.

Itératif :

Un flux itératif se produit lorsqu'un bloc d'un programme s'exécute de manière répétée. Le flux itératif est assuré par une structure appelée boucles en Java. L'utilisateur décide combien de fois le bloc s'exécute dans le programme.

Interrupteur

Description :

L'instruction switch est utilisée lorsque l'expression décisive peut prendre plus de deux valeurs. Cela signifie tester l'expression par rapport à une liste de valeurs.

Nous pouvons établir des similitudes entre Java if…else instructions et changement de casse.

Chaque bloc else-if peut être comparé au bloc case, et la variable est vérifiée à chaque case. Cependant, une grande différence entre eux est visible à travers le concept de chute.

La chute peut se produire avec un boîtier de commutation.

Syntaxe :

L'expression mentionnée dans le commutateur peut prendre des valeurs entières ou d'autres types de données primitifs entiers (octet, court, long) ou des chaînes. Un bloc de commutation peut inclure n'importe quel nombre de blocs de cas. La syntaxe des blocs de cas est d'écrire le mot-clé 'case' avec la valeur avec laquelle vous voulez vérifier, suivi de deux-points. Il est important de se rappeler que les valeurs des blocs de cas doivent être du même type de données que celui mentionné dans l'expression de commutateur. Switch-case n'autorise aucune autre opération relationnelle à l'exception de l'égalité.

Une syntaxe générale pour les instructions switch ressemble à :

switch (expression)
{
   case val1:
   {
       statement(s);
       break; // optional
   }
   case val2:
   {
       statement(s);
       break; // optional
   }
   default:
   {
       statement(s);
   }
}

Un exemple de la même chose serait :

ex.

int value = 10;
switch(value)
{
   case 10:
   {
      System.out.println("Value is 10");
      break;
   }

   case 20:
   {
      System.out.println("Value is 20");
      break;
   }

   default:
   {
      System.out.println("Default value is 0");
   }
}

Sortie :

Value is 10.

Organigramme :

Lorsque la variable correspond à la valeur d'un certain cas, les instructions du bloc case s'exécutent jusqu'à ce qu'une instruction break facultative se produise. "break" est un mot-clé en java qui s'assure qu'une fois atteint, le flux conditionnel se termine et que le contrôle séquentiel du flux est atteint. Ce qui signifie que le flux du programme atteint la ligne suivante après le bloc de commutation.

Le diagramme de flux vous aidera à visualiser le rôle de l'instruction break :

Echouer

Il n'est pas nécessaire d'inclure des instructions break pour tous les cas. Cependant, cela n'aurait aucun sens de ne pas le faire. Si la pause saute pour un cas correspondant, alors le compilateur est toujours dans le flux conditionnel et quelle que soit la valeur, qu'elle corresponde ou non, il continue à exécuter les blocs de cas suivants jusqu'à ce qu'il trouve une instruction break. En Java, nous appelons ce scénario Fall through.

Un exemple montre ci-dessous la condition d'échec :

int value = 10;
switch(value)
{
   case 10:
   {
      System.out.println("Value is 10");
   }

   case 20:
   {
      System.out.println("Value is 20");
   }

   case 30:
   {
      System.out.println("Value is 30");
   }

   default:
   {
      System.out.println("Default value is 0");
   }
}

Sortie :

Value is 10
Value is 20
Value is 30
Value is 0

Balise Java