Contenu du cours
Notions de Base de Java
Notions de Base de Java
Instruction Switch-Case
Gestion de plusieurs conditions différentes
Lorsque nous avons de nombreuses conditions à vérifier, utiliser plusieurs chaînes if-else peut ne pas être pratique.
Par exemple :
Main
package com.example; public class Main { public static void main(String[] args) { // You can change the value of the variable `a` to test the `if` statement int a = 30; if (a == 10) { System.out.println(10); } else if (a == 20) { System.out.println(20); } else if (a == 30) { System.out.println(30); } else if (a == 40) { System.out.println(40); } else { System.out.println(a); } } }
Nous pouvons voir que cela ne semble pas propre et professionnel. Pour de tels cas, Java fournit l'instruction switch-case.
Instruction switch-case
L'instruction switch-case se compose de plusieurs parties :
Main
switch (expression) { case value_1: // Code to be executed if expression matches `value_1` break; // Break is used to exit the `switch` statement. case value_2: // Code to be executed if expression matches `value_2` break; // Break is used to exit the `switch` statement. ............ default: // Code to be executed if no cases match // Optional, but executed if no other case matches }
Dans le code ci-dessus, vous pouvez voir que nous utilisons des blocs switch pour exécuter sélectivement des opérations. Nous nous appuyons sur l'expression, qui est légèrement différente d'une condition. Là, nous insérons une valeur ou une expression. Par exemple, 10 / 2. Dans ce cas, le bloc case avec la signature case 5 sera exécuté car l'expression ci-dessus est égale à 5.
Nous pouvons également utiliser une condition ici. Dans ce cas, nous devons écrire une expression booléenne dans le bloc d'expression, et cela devrait ressembler à ceci : 10 / 2 == 5. Ensuite, écrivez deux cas ci-dessous :
Mais cette structure sera presque indiscernable d'un if-else régulier.
Le mot-clé "break"
Nous utilisons ce mot-clé pour terminer l'exécution d'une instruction switch-case et sortir de son corps. Ce mot est souvent utilisé dans les boucles, que nous aborderons dans les chapitres suivants. Utilisez ce mot-clé lorsque vous avez besoin de sortir d'un bloc de code et d'arrêter son exécution.
Améliorons maintenant le code que nous avons écrit ci-dessus en utilisant l'instruction switch-case :
Main
package com.example; public class Main { public static void main(String[] args) { // You can change the value of the variable `a` to test the `switch` statement int a = 30; switch (a) { case 10: System.out.println(10); break; case 20: System.out.println(20); break; case 30: System.out.println(30); break; case 40: System.out.println(40); break; default: System.out.println("There is no matching value"); } } }
Nous pouvons voir comment le code est devenu beaucoup plus propre et plus facile à lire et à étendre. Nous n'avons pas besoin d'écrire une autre instruction if à partir de zéro si nous devons ajouter des conditions supplémentaires. Au lieu de cela, nous pouvons ajouter un autre bloc de cas à notre switch-case statement.
Regardons le schéma du bloc switch-case :
Comme nous pouvons le voir, il peut y avoir autant de cas que nous le souhaitons. Chaque cas nécessite sa propre condition et son propre code, qui seront exécutés lorsque notre programme entrera dans le bloc de cas.
Il est conseillé d'utiliser le mot-clé break car le programme ne quittera pas le bloc switch tant que tous les blocs de cas n'auront pas été exécutés. Le bloc par défaut sera exécuté si nous n'entrons dans aucun de nos blocs de cas ou si nous n'utilisons pas le mot-clé break.
Regardons un autre exemple sans les mots-clés break :
Main
package com.example; public class Main { public static void main(String[] args) { // You can change the value of the variable `a` to test the `switch` statement int a = 10; switch (a) { case 10: System.out.println(10); case 20: System.out.println(20); case 30: System.out.println(30); case 40: System.out.println(40); default: System.out.println("There is no matching value"); } } }
Nous avons reçu plusieurs valeurs, qui diffèrent de ce que nous attendions. De plus, nous avons obtenu des informations des blocs case 10 et default. C'est précisément pourquoi nous utilisons le mot-clé break après chaque bloc. De cette façon, le programme quittera l'instruction switch et continuera son exécution.
1. Quelle sera la sortie sur la console ?
2. Pourquoi avons-nous besoin du mot-clé break ?
Merci pour vos commentaires !
