Qu'est-ce que la déclaration de cas en Java?
Lors de la programmation, il est très difficile à gérer lorsqu'il s'agit de gérer différentes actions dans différentes conditions. Bien qu'en Java et dans de nombreux autres langages de programmation, des instructions comme if, if-else, if-else-if sont utilisées en cas de conditions diverses. Mais que se passe-t-il s'il y a 'n' nombre de scénarios qui nécessitent des actions distinctes pour chaque condition? Plusieurs instructions if et else-if à ce stade peuvent entraîner une 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 programmation et réduire la ligne de code et la complexité.
L'instruction switch est une instruction de branche. La casse est un mot clé utilisé avec l'instruction Switch. Il exécute l'instruction / les instructions lorsque la valeur de l'expression correspond à la valeur de casse et que le code des instructions particulières se termine par le mot-clé break. Les valeurs Case en Java peuvent être des types de données byte, int, short, byte. Avec Java JDK7, la valeur de la casse peut également être des types String, Wrapper et énumérés. 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 par défaut et break ne soient pas obligatoires dans les instructions Switch-Case.
Comment fonctionne la déclaration de cas en Java?
Comme décrit ci-dessus, Case dans une instruction Switch particulière est exécutée lorsque la valeur de l'expression correspond à la valeur Case. Si aucune des valeurs ne correspond aux valeurs Case, l'instruction par défaut définie dans le bloc Switch est exécutée, sinon rien n'est 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 même 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 identique à 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 la rupture n'est utilisée dans aucune des déclarations de cas, il n'y aurait pas d'erreur à la place, tous les cas procédant au cas correspondant seront exécutés.
- Le bec et les mots clés 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 value2:
//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 boîtier de commutateur
L'organigramme ci-dessus montre clairement le fonctionnement de l'instruction Switch and 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 n'est pas mise en correspondance jusqu'à la dernière étape, c'est-à-dire que false 'est renvoyé à la fin de chaque cas, alors le code à l'intérieur du' default 'est exécuté. Si la valeur de n'importe quel cas correspond à l'expression, c'est-à-dire retourne «vrai» dans l'une des instructions Case, alors le code du bloc particulier est exécuté, puis l'exécution quitte le bloc Switch.
Exemples d'instructions C ase en Java
Les exemples ci-dessous montrent clairement le fonctionnement de l'instruction Case en Java.
Exemple 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;
)
)
)
Production:
Exemple # 2
Lorsqu'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;
)
)
)
Production:
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;
)
)
)
Production:
Exemple # 4
Lorsqu'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;
)
)
)
Production:
Conclusion
Dans cet article ci-dessus, nous avons mentionné presque tous les scénarios des instructions switch et les sorties qui peuvent être générées par eux. Bien qu'il soit très facile de travailler sur des instructions Switch, il doit être bien compris par le programmeur avant de travailler dessus, car cela peut parfois produire des résultats inattendus si des 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ésolues avec des instructions if-else -if.
Article recommandé
Cela a été un guide pour la déclaration de cas 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 -
- Motifs d'étoiles en Java
- Outils Java
- Cadres en Java
- Meilleurs compilateurs Java
- Guide de déclaration de cas en JavaScript
- Switch Case dans PowerShell avec leurs exemples