Déclaration de cas en Java

Lors de la programmation, il est très difficile de gérer différentes actions dans différentes conditions. Bien qu'en Java et dans de nombreux autres langages de programmation, des instructions telles que if-else, if-else-if sont utilisées dans diverses conditions. Mais que se passe-t-il s’il existe un nombre « n » de scénarios qui nécessitent des actions distinctes pour chaque condition ? Plusieurs instructions if et else-if à ce stade peuvent prêter à confusion pour le programmeur à un moment donné du code, car elles impliquent plusieurs accolades et un ensemble d'instructions pour chaque condition. Pour gérer de telles situations en Java, les instructions Switch-Case sont utilisées pour faciliter la tâche du programmeur et réduire la ligne de code et la complexité.

L'instruction switch est une instruction de branchement. Le cas est un mot-clé utilisé avec l'instruction Switch. Il effectue l'exécution d'une ou plusieurs instructions lorsque la valeur de l'expression correspond à la valeur du cas et que le code des instructions particulières se termine par le mot-clé break. Les valeurs de cas en Java peuvent être des types de données octet, int, court et octet. Avec le Java JDK7, la valeur de la casse peut également être de type String, Wrapper et énuméré. Si l'une des valeurs de Case ne correspond pas à l'expression, l'instruction par défaut est exécutée. Bien que les mots-clés default et break ne soient pas obligatoires dans les instructions Switch-Case.

Commencez votre cours de développement de logiciels libres

Développement Web, langages de programmation, tests de logiciels et autres

Comment fonctionne l'instruction Case en Java ?

Comme décrit ci-dessus, Case dans une instruction Switch particulière est exécuté lorsque la valeur de l'expression correspond à la valeur Case. Si aucune des valeurs ne correspond aux valeurs de cas, alors l'instruction par défaut définie dans le bloc Switch est exécutée ; sinon, rien n'a été exécuté.

Points importants à résumer :

• Il peut y avoir plusieurs blocs de commutation dans le programme, en fonction des différentes conditions.
• Il peut y avoir n'importe quel nombre d'instructions Case dans un seul bloc Switch.
• Les valeurs en double dans les instructions Case ne sont pas autorisées.
• Le type de données de la variable de l'instruction switch doit être le même que la valeur de l'instruction Case.
• Les variables ne sont pas autorisées pour la valeur Case. La valeur peut être constante ou littérale.
• Le mot-clé Break dans chaque cas est utilisé pour terminer cette séquence particulière d'instructions de ce cas. Si le break n'est utilisé dans aucun cas, il n'y aura pas d'erreur ; au lieu de cela, tous les cas en cours avec le cas correspondant seront exécutés.
• Les mots-clés Beak et par défaut sont facultatifs dans les blocs Switch.

Syntaxe de l'instruction Switch Case en Java

switch (expression)
{
// case statements
// same data type for switch expression and case value Case value1:
//Statement /statements to be executed
break;
case value 2:
//Statement /statements to be executed
break;
case value'n':
//Statement /statements to be executed
break;
// There can be as many Cases as the user wants in a Switch block
//default is an optional case and executed if none of the case values matches the expression
default:
//statement
}

Organigramme de la déclaration du cas de commutation

L'organigramme ci-dessus montre clairement comment fonctionnent les instructions Switch et Case en Java. Il montre comment la correspondance de l'expression définie dans l'instruction Switch est mise en correspondance avec la valeur Case en commençant par le haut jusqu'aux dernières étapes. Si la valeur ne correspond pas avant la dernière étape, c'est-à-dire que false' est renvoyé à la fin de chaque cas, alors le code à l'intérieur de 'default' est exécuté. Si la valeur d'un cas correspond à l'expression, c'est-à-dire renvoie « vrai » dans l'une des instructions Case, alors le code d'un bloc particulier est exécuté, puis l'exécution quitte le bloc Switch.

Exemples d'instruction Case en Java

Les exemples ci-dessous montrent clairement comment fonctionne l'instruction Case en Java.

Exemple n°1

Lorsque la valeur de l'expression Switch correspond à une valeur Case

Code :

public class MyClass {
public static void main(String args[]) {
int value = 8;
switch (value)
{
case 3:
System.out.println("Congratulations here is the case 3 executed"); break;
case 4:
System.out.println("Congratulations here is the case 4 executed"); break;
case 8:
System.out.println("Congratulations here is the case 8 executed"); break;
default:
System.out.println("Sorry none of your cases matched"); break;
}
}
}

Sortie :

Exemple n°2

Quand aucune valeur ne correspond à l'expression Switch

Code :

public class MonthClass {
public static void main(String args[]) {
int month= 13;
switch (month)
{
case 1:
System.out.println("Month is January"); break;
case 2:
System.out.println("Month is February"); break;
case 4:
System.out.println("Month is April");
break;
default:
System.out.println("Sorry either the value you have given is invalid or not matched with any of the case.");
break;
}
}
}

Sortie :

Exemple #3

Lorsqu'il manque un mot-clé break dans les instructions Case

Code :

public class VowelClass{
public static void main(String args[]) {
char ch = 'a';
switch (ch)
{
case 'e':
System.out.println("Value matched - e, a vowel\n"); break;
case 'a':
System.out.println("Value matched - a, a vowel"); case 'w':
System.out.println("Value matched - w, not a vowel"); case 'o':
System.out.println("Value matched - o, a vowel"); default:
System.out.println("Sorry none of your cases matched"); break;
}
}
}

Sortie :

Exemple n°4

Quand il n'y a pas de bloc par défaut dans le bloc de commutation

Code :

public class NoOutputClass {
public static void main(String args[]) {
char grades = 'D';
switch (grades)
{
Case 'A':
System.out.println("Grade A - Excellent");
break;
case 'B':
System.out.println("Grade B - Good");
break;
case 'C':
System.out.println("Grade C - Poor");
break;
}
}
}

Sortie :

Conclusion

Dans l'article ci-dessus, nous avons mentionné presque tous les scénarios des instructions switch et les sorties qu'elles peuvent générer. Bien qu'il soit très facile de travailler sur les instructions Switch, le programmeur doit bien le comprendre avant de travailler dessus, car cela peut parfois produire des résultats inattendus si certaines erreurs sont commises. Normalement, Switch doit être utilisé dans un scénario où il est nécessaire d’effectuer l’action dans certaines conditions, et les conditions sont nombreuses. Dans le cas de seulement 2-3 conditions, les choses peuvent être réglées avec des instructions if-else-if.

Article recommandé

Ceci a été un guide sur Case Statement en Java. Nous discutons ici du diagramme de flux de l'instruction Switch-Case en Java ainsi que de la syntaxe avec des exemples. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus –

1. Modèles d'étoiles en Java
2. Frameworks en Java
3. Meilleurs compilateurs Java
4. Déclaration de cas en JavaScript

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!