Menu

Instruction de cas de commutateur Java avec des exemples de programmation

  • Principal
  • Autre
  • Instruction de cas de commutateur Java avec des exemples de programmation

java switch case statement with programming examples

Essayez Notre Instrument Pour Éliminer Les Problèmes

Découvrez la déclaration Java Switch, le commutateur imbriqué, d'autres variantes et son utilisation à l'aide d'exemples simples:

Dans ce didacticiel, nous aborderons l'instruction Java Switch. Ici, nous explorerons chaque concept lié à l'instruction Switch avec les exemples de programmation et leur description.

Vous recevrez suffisamment d'exemples qui vous permettront de mieux comprendre le sujet et vous permettront également de créer vos programmes chaque fois que vous devrez utiliser l'instruction Switch.

Certaines des questions fréquemment posées sont incluses afin que vous soyez au courant des questions de tendance qui sont posées concernant l'instruction Switch.

=> Jetez un œil au guide du débutant Java ici.

Instruction Java Switch (1)

Ce que vous apprendrez:

quelle couche du modèle osi traite le cryptage des données?

Instruction Java Switch

Dans ce didacticiel, nous couvrirons les variantes suivantes de l'instruction Java Switch.

  • Instruction Switch
  • Instruction de commutateur imbriqué (commutateur interne et externe)

L'instruction Switch en Java est une instruction de branche ou une instruction de prise de décision qui fournit un moyen d'exécuter votre code sur différents cas ou parties basés sur la valeur de l'expression ou de la condition. Plus souvent que cela, l'instruction Java Switch fournit une meilleure alternative que les différentes options disponibles avec les instructions Java if-else.

Syntaxe:

switch (expression){ case 1: //statement of case 1 break; case 2: //statement of case 2 break; case 3: //statement of case 3 break; . . . case N: //statement of case N break; default; //default statement }

Instruction Java Switch

Règles pour une instruction Switch

Vous trouverez ci-dessous les règles importantes pour une instruction Switch.

  • Les observations ou valeurs de cas en double ne sont pas autorisées.
  • La valeur du cas Switch doit être du même type de données que la variable Case Switch. Pour Par exemple. - si «x» est de type entier dans un «switch (x)», alors tous les cas Switch doivent être de type entier.
  • Le Instructions de rupture Java peut être utilisé (facultatif) pour terminer la séquence d'exécutables à l'intérieur d'un cas.
  • La déclaration par défaut est également facultative. Habituellement, il est présent à la fin d'une instruction Switch. L'instruction par défaut est exécutée si aucun des cas Switch ne correspond à la valeur de la variable Switch.
  • La valeur d'un cas Switch doit être une constante et non une variable.

Boîtier de commutation utilisant la boucle For

Vous trouverez ci-dessous l'exemple de programme dans lequel nous avons démontré comment l'instruction Java Switch fonctionne ou peut être utilisée dans les programmes. Tout d'abord, nous avons initialisé la valeur de «i» à l'intérieur de la boucle for et spécifié la condition.

Ensuite, nous avons implémenté l'instruction Switch avec deux cas et un par défaut. L'instruction par défaut continuera à s'exécuter jusqu'à ce que «i<5”. In this case, it will execute 2 times for “i=3” and “i=4”.

public class example { public static void main(String() args) { /* * Switch statement starts here. Added three cases and * one default statement. The default statement will * keep on executing until i<5. In this case, it will * execute 2 times for i=3 and i=4. */ for(int i=0; i<5; i++) { switch(i){ case 0: System.out.println('i value is 0'); break; case 1: System.out.println('i value is 1'); break; case 2: System.out.println('i value is 2'); break; default: System.out.println('i value is greater than 2 and less than 5'); } } } }

Production:

Boîtier de commutation utilisant la boucle for - sortie

La pause est facultative

Dans Switch case Java, l'instruction break est facultative. Même si vous supprimez la pause, le contrôle du programme passera au cas suivant.

Prenons l'exemple suivant.

public class example { public static void main(String() args) { /* * Switch statement starts here. Added 10 cases and * one default statement. Execution will flow through * each of these cases case 0 to case 4 and case 5 to * case 9 until it finds a break statement. */ for(int i=0; i<=10; i++) { switch(i){ case 0: case 1: case 2: case 3: case 4: System.out.println('i value is less than 5'); break; case 5: case 6: case 7: case 8: case 9: System.out.println('i value is less than 10'); break; default: System.out.println('Default statement'); } } } }

Production

La pause est facultative - sortie

Instruction de commutateur imbriqué

Cela implique le concept d'un interrupteur interne et externe. Nous pouvons utiliser un commutateur interne dans le cadre de l'instruction d'un commutateur externe. Ce type d'instruction Switch est appelé l'instruction Nested Switch ou Switch (Inner) à l'intérieur d'un Switch (Outer) est appelé Nested Switch.

Syntaxe:

switch (count){ case 1: switch (target){ //nested switch statement case 0: System.out.println(“target is 0”); break; case 1: System.out.println(“target is 1”); break; } break; case 2: //… }

Recherche de «a» et «b» à l’aide du commutateur imbriqué

Dans l'exemple ci-dessous, nous avons utilisé la classe Scanner pour saisir «a» et «b» via la console. Ensuite, nous avons utilisé l'interrupteur interne et externe pour définir des cas différents pour la valeur de «a» et «b».

Le contrôle passera par ces instructions Switch internes et externes et si la valeur entrée correspond, il imprimera la valeur. Sinon, la déclaration par défaut sera imprimée.

import java.util.Scanner; public class example { public static void main(String() args) { int a,b; System.out.println('Enter a and b'); Scanner in = new Scanner(System.in); a = in.nextInt(); b = in.nextInt(); // Outer Switch starts here switch (a) { // If a = 1 case 1: // Inner Switch starts here switch (b) { // for condition b = 1 case 1: System.out.println('b is 1'); break; // for condition b = 2 case 2: System.out.println('b is 2'); break; // for condition b = 3 case 3: System.out.println('b is 3'); break; } break; // for condition a = 2 case 2: System.out.println('a is 2'); break; // for condition a == 3 case 3: System.out.println('a is 3'); break; default: System.out.println('default statement here'); break; } } }

Production

Recherche de a et b à l

Instruction Switch utilisant une chaîne

Dans JDK 7.0 et supérieur, nous sommes autorisés à utiliser des objets String dans l'expression ou la condition Switch.

Ci-dessous est l'exemple où nous avons utilisé des chaînes dans l'instruction Switch. Nous pouvons utiliser des chaînes dans une instruction Switch, tout comme des entiers.

import java.util.Scanner; public class example { public static void main(String() args) { String mobile = 'iPhone'; switch (mobile) { case 'samsung': System.out.println('Buy a Samsung phone'); break; case 'iPhone': System.out.println('Buy an iPhone'); break; case 'Motorola': System.out.println('Buy a Motorola phone'); } } }

Production

Instruction Switch utilisant une chaîne

Wrapper dans une instruction Switch

À partir de JDK 7.0, l'instruction Switch fonctionne également avec la classe Wrapper. Ici, nous allons démontrer Java Wrapper dans une instruction Switch.

Dans l'exemple ci-dessous, nous avons utilisé une classe Integer qui encapsule une valeur du type primitif int dans un objet. En utilisant cette classe, nous avons initialisé une variable Wrapper «x» avec la valeur 3.

En utilisant la variable Wrapper (dans une instruction Switch), nous avons défini trois cas différents avec un cas par défaut. Quel que soit le cas correspondant à la valeur de «x», ce cas particulier sera exécuté.

public class example { public static void main(String() args) { // Initializing a Wrapper variable Integer x = 3; // Switch statement with Wrapper variable x switch (x) { case 1: System.out.println('Value of x = 1'); break; case 2: System.out.println('Value of x = 2'); break; case 3: System.out.println('Value of x = 3'); break; // Default case statement default: System.out.println('Value of x is undefined'); } } }

Production

Wrapper dans une instruction Switch

Énumération Java dans une instruction Switch

Dans JDK 7.0 et supérieur, l'instruction Switch fonctionne bien avec l'énumération Java. Dans cette section, nous allons démontrer l'énumération Java dans une instruction switch.

Ici, nous avons créé une énumération appelée chaussures avec quatre constantes qui sont essentiellement des marques de chaussures. Ensuite, nous avons stocké l'énumérateur dans la variable de référence a1.

En utilisant cette variable de référence a1, nous avons initialisé une instruction Switch avec quatre cas différents. Quel que soit le cas correspondant à la valeur de la variable de référence, ce cas particulier sera exécuté.

/* * created an enumeration called shoes * with four enumerators. */ enum shoes { Nike, Adidas, Puma, Reebok; } public class example { public static void main(String() args) { /* * stored enumerator in reference variable a1 for constant = Adidas */ shoes a1 = shoes.Adidas; /* * Started Switch Statement and if the element matches with a1 then it * will print the statement specified in the case */ switch (a1) { // does not match case Nike: System.out.println('Nike - Just do it'); break; // matches case Adidas: System.out.println('Adidas - Impossible is nothing'); break; // does not match case Puma: System.out.println('Puma - Forever Faster'); break; // does not match case Reebok: System.out.println('Reebok - I Am What I Am'); break; } } }

Production

Énumération Java dans une instruction switch

Questions fréquemment posées

Q # 1) Qu'est-ce qu'une instruction Java Switch?

Répondre: L'instruction Switch en Java est une instruction de branche ou une instruction de prise de décision (tout comme l'instruction Java if-else) qui fournit un moyen d'exécuter le code dans différents cas. Ces cas sont basés sur une expression ou une condition.

La plupart du temps, l'instruction Java Switch s'est avérée être une meilleure alternative pour la prise de décision que l'instruction Java if-else.

Q # 2) Comment écrivez-vous une instruction Switch en Java?

Répondre: Vous trouverez ci-dessous un exemple de programme dans lequel nous avons utilisé l'instruction Switch. Ici, nous avons pris un entier appelé brand avec la valeur 4, puis utilisé cet entier dans une instruction Switch pour différents cas.

La valeur entière de la marque correspond à la casse, puis la déclaration de ce cas particulier sera imprimée.

import java.util.Scanner; public class example { public static void main(String() args) { int brand = 4; String name; // Switch statement starts here switch(brand){ case 1: name = 'Nike'; break; case 2: name = 'Dolce & Gabbana'; break; case 3: name = 'Prada'; break; case 4: name = 'Louis Vuitton'; break; default: name = 'Invalid name'; break; } System.out.println('The brand name is: ' + name); } }

Production

Instruction Switch en Java

Q # 3) Donnez un exemple d'instruction Switch.

Répondre: Il existe de nombreux exemples d'instruction Switch dans ce didacticiel. Nous avons donné tous les exemples possibles, que ce soit Switch with Integer ou Switch with String.

Vous pouvez vous référer aux exemples donnés au début de ce didacticiel afin de connaître les bases d'une instruction Switch et son utilisation avec les boucles. (Reportez-vous à la section «Boîtier de commutation utilisant la boucle for»)

Q # 4) Avez-vous besoin d'un cas par défaut dans une instruction switch?

Répondre: Non, il n'est pas obligatoire d'utiliser la casse par défaut chaque fois que vous traitez avec l'instruction Switch.

Par exemple, si vous voyez l'exemple ci-dessous où nous n'avons pas utilisé de cas par défaut. Même si nous n'utilisons pas le cas par défaut, le programme s'exécutera parfaitement tant qu'il trouvera le cas correspondant.

import java.util.Scanner; public class example { public static void main(String() args) { String author = 'Saket'; switch (author) { case 'John': System.out.println('John is the author'); break; case 'Michael': System.out.println('Michael is the author'); break; case 'Rebecca': System.out.println('Rebecca is the author'); break; case 'Saket': System.out.println('Saket is the author'); break; case 'Steve': System.out.println('Steve is the author'); break; } } }

Production

Instruction Switch - exemple

Conclusion

Dans ce didacticiel, nous avons présenté l'instruction Java Switch ainsi que la syntaxe, la description et l'organigramme. Une autre variante qui est l'instruction Nested Switch est également discutée en détail avec les exemples appropriés, y compris le concept de commutateur interne et externe.

Certaines questions fréquemment posées sont également fournies ici afin que vous puissiez connaître les questions de tendance liées à l'instruction Java Switch. Ces déclarations de prise de décision seront utiles lorsque vous souhaitez séparer le code en fonction d'une condition ou d'une expression et que vous souhaitez vérifier plusieurs cas.

=> Consultez TOUS les didacticiels Java ici.

lecture recommandée