Énoncé de cas de commutateur Java

'Caste-case ' La déclaration peut être utilisée comme alternative de 'if-else-if ' déclaration où différentes conditions sont définies dans différents 'si' affirmations. Si la première condition retourne fausse, vérifiez la deuxième condition et ainsi de suite. Définir plusieurs conditions en utilisant de cette façon est un processus très long. La même tâche peut être effectuée très simplement en utilisant un commutateur déclaration. Il contient différentes pièces d'exécution et exécute l'instruction où la valeur particulière correspond à tout 'cas' valeur. L'interrupteur La déclaration peut être appliquée aux différents types de données primitives telles que int, char, octet, etc. Les différentes utilisations de commutateur Les déclarations en Java sont expliquées dans ce tutoriel.

Syntaxe:

commutateur (variable ou expression)
Valeur 1 du cas:
Déclaration 1… n
casser;
Valeur de cas-2:
Déclaration 1… n
casser;
.
.
.
Valeur de cas-n:
Déclaration 1… n
casser;
défaut :
Déclaration 1… n

Ici, vous pouvez utiliser n'importe quelle variable ou expression dans le changer partie qui sera appariée avec le cas valeur. 'casser'déclaration et'défaut'La partie est facultative pour le casier déclaration. Mais si le 'casser' La déclaration est omise pour tout ou partie cas instructions, puis la valeur de cas suivante ou toutes les valeurs de cas seront vérifiées avec la valeur définie de l'interrupteur partie. Si aucun des cas La valeur correspond à changer valeur, puis les déclarations du défaut la pièce sera exécutée. Comment le casier La déclaration fonctionne avec et sans parties facultatives ci-dessous en utilisant différents exemples.

Exemple-1: utilisation de l'instruction de cas de commutateur sans interruption et par défaut

L'exemple suivant montre comment fonctionne l'instruction de cas de commutateur lorsque non casser et défaut Les déclarations sont utilisées. Une données de chaîne sera prise en entrée et stockée dans la variable, IDENTIFIANT, et la valeur du IDENTIFIANT sera vérifié avec chaque valeur de cas. Il imprimera non seulement le message où la valeur de cas correspond à la valeur de l'ID mais imprimera également tous les messages de la section de cas restante car non casser La déclaration est utilisée. Si aucune valeur de cas ne correspond à IDENTIFIANT valeur, alors aucun message n'imprime car non défaut La section est utilisée dans le code.

// Importer un package de scanner
Importer Java.user.Scanner;
classe publique Switch1
public static void main (String [] args)
// Créer un objet de scanner
Entrée du scanner = nouveau scanner (système.dans);
Système.dehors.print ("Entrez votre ID:");
// Prenez des données de chaîne de l'utilisateur
String id = entrée.suivant();
// Switch Expression
commutateur (id)
// Déclaration de cas-1
cas "0111786":
Système.dehors.println ("Votre lot est 24");
// Déclaration de cas-2
cas "0111234":
Système.dehors.println ("Votre lot est de 20");
// Déclaration de cas-3
cas "0111923":
Système.dehors.println ("Votre lot est 37");

// Fermez l'objet scanner
saisir.fermer();

Sortir:

La sortie suivante apparaîtra si la valeur d'entrée correspond à la première valeur de cas après l'exécution du script. Les deux derniers messages sont imprimés ici pour omettre le casser déclaration.

Lorsque la valeur d'entrée correspond à la deuxième valeur de cas, la sortie suivante apparaîtra.

Lorsque la valeur d'entrée ne correspond à aucune valeur de cas, aucune sortie n'apparaîtra pour l'omission défaut section.

Exemple-2: utilisation de l'instruction de cas de commutateur avec la section par défaut

Le défaut La section est essentielle pour un bloc de cas de commutateur pour imprimer un message à l'utilisateur que aucune correspondance n'est trouvée. L'exemple suivant montre l'utilisation de la section par défaut dans le bloc de cas de commutateur. Ici, la valeur du nombre sera vérifiée avec chaque valeur de cas de l'instruction de case, et aucune correspondance n'est trouvée, puis le message du défaut La section sera imprimée.

classe publique Switch2
public static void main (String [] args)
int numéro = 380;
commutateur (numéro)
// Déclaration de cas-1
Cas 440:
Système.dehors.println ("vous êtes sélectionné pour le groupe A");
// Déclaration de cas-2
Cas 500:
Système.dehors.println ("vous êtes sélectionné pour le groupe B");
// Déclaration de cas-3
Cas 890:
Système.dehors.println ("vous êtes sélectionné pour le groupe C");
// Exécuter l'instruction par défaut si tout le cas retourne faux
défaut:
Système.dehors.println ("Désolé, vous n'êtes pas sélectionné");

Sortir:

La sortie suivante apparaîtra après avoir exécuté le code. Selon le code, la valeur attribuée dans le nombre la variable ne correspond à aucune valeur de cas. Donc, le message du défaut La section est imprimée ici.

Exemple-3: utilisation de l'instruction de cas de commutateur avec défaut et pause

L'exemple suivant montre l'utilisation d'une instruction de cas de commutateur avec la section par défaut et rompt l'instruction. Ici, le code de cours sera pris comme entrée de l'utilisateur, et cela sera vérifié avec chaque valeur de cas. S'il existe une correspondance, les instructions de la section de cas de correspondance seront exécutées et le programme se terminera du bloc de cas de commutateur pour l'utilisation d'un casser déclaration. Si aucune correspondance n'existe, alors les instructions de la section par défaut seront exécutées.

// Importer un package de scanner
Importer Java.user.Scanner;
Switch de classe publique3
public static void main (String [] args)
// Créer un objet de scanner
Entrée du scanner = nouveau scanner (système.dans);
Système.dehors.print ("Entrez le code de cours:");
// Prenez des données de chaîne de l'utilisateur
Code de chaîne = entrée.suivant();
commutateur (code)
// Déclaration de cas-1
cas "CSE-105":
Système.dehors.println ("Nom du cours: programmation Java");
Système.dehors.println ("heure de crédit: 2");
Système.dehors.println ("Semestre: 2");
casser;
// Déclaration de cas-2
cas "CSE-207":
Système.dehors.println ("Nom du cours: structure de données");
Système.dehors.println ("heure de crédit: 2");
Système.dehors.println ("Semestre: 4");
casser;
// Déclaration de cas-3
cas "CSE-402":
Système.dehors.println ("Nom du cours: intelligence artificielle");
Système.dehors.println ("heure de crédit: 3");
Système.dehors.println ("Semestre: 10");
casser;
// Exécuter l'instruction par défaut si tout le cas retourne faux
défaut:
Système.dehors.println ("code de cours non valide");

// Fermez l'objet scanner
saisir.fermer();

Sortir:

Après avoir exécuté le code, il demandera le code de cours de l'utilisateur. Ici, CSE-105 est pris comme une entrée qui correspond à la première valeur de cas. Ainsi, les détails des informations du cours sont imprimés et d'autres sections de cas sont omises pour l'utilisation d'un casser déclaration.

Suivant, CSE-402 est pris comme une entrée qui correspond à la dernière valeur de cas, et les détails du cours correspondants sont imprimés.

Suivant, CSE-101 est pris comme une entrée qui ne correspond à aucune valeur de cas, et le message de la section par défaut est imprimé.

Conclusion:

L'utilisation d'une instruction Switch-Case est efficace dans de nombreux cas au lieu d'utiliser l'instruction if-else-if pour résoudre des problèmes particuliers. Le concept et l'utilisation de l'instruction Switch-Case sont expliqués de manière appropriée dans ce tutoriel pour aider les utilisateurs de Java à l'appliquer efficacement dans leur code en fonction de l'exigence.