Qu'est-ce qu'un Switch Case en Java et comment l'utiliser ?

Le switch case en Java est l'une des nombreuses instructions Java qui indiquent au langage de programmation quoi faire. Comme les phrases en anglais qui donnent une idée complète du texte et des clauses d'inclusion, les instructions Java sont des commandes comprenant une ou plusieurs expressions que l'interpréteur Java exécute. En termes plus simples, une instruction Java est une instruction expliquant ce qui doit se passer.

Une instruction Java se termine par un point-virgule (;) et indique à Java de traiter les instructions jusqu'à ce point-virgule. Par défaut, l'interpréteur Java suit l'ordre dans lequel les instructions sont écrites et exécute une instruction après l'autre. Cependant, les instructions qui contrôlent le déroulement du programme (instructions de contrôle de flux), telles que les boucles et les conditions, ne suivent pas l'ordre d'exécution par défaut. Cet article se concentre sur un tel type de mécanisme de contrôle de sélection - l' instruction Java switch case.

Qu'est-ce qu'un switch case en Java ?

Java prend en charge trois types d'instructions : les instructions d'expression pour modifier les valeurs des variables, appeler des méthodes et créer des objets, les instructions de déclaration pour déclarer des variables et les instructions de flux de contrôle pour déterminer l'ordre d'exécution des instructions.

L' instruction Java switch case est un type d'instruction de flux de contrôle qui permet à la valeur d'une expression ou d'une variable de modifier le flux de contrôle de l'exécution du programme via une branche multidirectionnelle. Contrairement aux instructions if-then et if-then-else, l'instruction Java switch a plusieurs chemins d'exécution. Switch case en Java fonctionne avec les types de données primitifs short, byte, int et char. À partir de JDK7, le commutateur Java peut également être utilisé avec la classe String, les types énumérés et les classes Wrapper qui encapsulent des types de données primitifs tels que Byte, Character, Integer et Short.

Le corps d'une instruction switch case en Java est appelé un bloc switch. Chaque instruction du bloc switch est étiquetée à l'aide d'un ou plusieurs cas ou étiquettes par défaut. Par conséquent, l'instruction switch évalue son expression, suivie de l'exécution de toutes les instructions qui suivent l'étiquette case correspondante.

Vous trouverez ci-dessous la syntaxe de l'instruction switch case :

// instruction switch

changer (expression)

{

// déclarations de cas

// les valeurs doivent être du même type d'expression

case value1 :

// Déclarations

Pause; // break est facultatif

case value2 :

// Déclarations

Pause; // break est facultatif

// Nous pouvons avoir n'importe quel nombre d'instructions de cas

// ci-dessous est l'instruction par défaut, utilisée lorsqu'aucun des cas n'est vrai.

// Aucune pause n'est nécessaire dans le cas par défaut.

défaut :

// Déclarations

}

Exemple d'instruction de commutateur Java

L'exemple de code Java suivant déclare un entier nommé "mois" dont la valeur représente l'un des 12 mois de l'année. Le code utilise l'instruction switch case pour afficher le nom du mois en fonction de la valeur du mois.

classe publique SwitchExample {

public static void main(String[] args) {

entier mois = 6 ;

Chaîne monthString ;

changer (mois) {

cas 1 : monthString = « Janvier » ;

Pause;

cas 2 : monthString = « Février » ;

Pause;

cas 3 : monthString = "Mars" ;

Pause;

cas 4 : moisChaîne = "Avril" ;

Pause;

cas 5 : monthString = « mai » ;

Pause;

cas 6 : monthString = « juin » ;

Pause;

cas 7 : monthString = « juillet » ;

Pause;

cas 8 : monthString = « août » ;

Pause;

cas 9 : monthString = « septembre » ;

Pause;

cas 10 : monthString = « octobre » ;

Pause;

cas 11 : monthString = « novembre » ;

Pause;

cas 12 : monthString = « décembre » ;

Pause;

par défaut : monthString = "Mois invalide" ;

Pause;

}

System.out.println(monthString);

}

}

Sortie : juin

Objectif de l'instruction break dans le cas du commutateur Java

L'instruction break est un aspect essentiel du cas de commutateur Java qui termine l'instruction switch englobante. L'instruction break est requise car sans elle, les instructions du bloc switch échoueraient. Ainsi, quelle que soit l'expression des étiquettes de cas suivantes, toutes les instructions après l'étiquette de cas correspondante sont exécutées séquentiellement jusqu'à ce qu'une instruction break soit rencontrée.

Le code suivant est un exemple pour montrer un bloc de commutateur qui échoue en l'absence de l'instruction break.

classe publique SwitchExampleFallThrough {

public static void main(String[] args) {

java.util.ArrayList<String> futureMonths =

nouveau java.util.ArrayList<String>();

entier mois = 6 ;

changer (mois) {

cas 1 : futureMonths.add("Janvier");

cas 2 : futureMonths.add("Février");

cas 3 : futureMonths.add("mars");

cas 4 : futureMonths.add("Avril");

cas 5 : futureMonths.add("Mai");

cas 6 : futureMonths.add("Juin");

cas 7 : futureMonths.add("juillet");

cas 8 : futureMonths.add("Août");

cas 9 : futureMonths.add("Septembre");

cas 10 : futureMonths.add("Octobre");

cas 11 : futureMonths.add("Novembre");

cas 12 : futureMonths.add("Décembre");

Pause;

par défaut : pause ;

}

si (futureMonths.isEmpty()) {

System.out.println("Numéro de mois invalide");

} autre {

for (String monthName : futureMonths) {

System.out.println(monthName);

}

}

}

}

Sortir:

juin

juillet

août

septembre

octobre

novembre

décembre

Le code ci-dessus affiche le mois de l'année correspondant au mois entier et les mois qui suivent. Ici, l'instruction break finale ne sert à rien car le flux sort de l'instruction switch. L'utilisation de l'instruction break est utile car elle rend le code moins sujet aux erreurs et facilite les modifications. La section par défaut du code gère toutes les valeurs qui ne sont réglementées par aucune des sections de cas.

Instruction de commutateur Java avec plusieurs étiquettes de cas

Les instructions switch en Java peuvent également avoir plusieurs étiquettes de cas. Le code suivant illustre la même chose - ici, le nombre de jours d'un mois particulier de l'année est calculé.

classe SwitchMultiple{

public static void main(String[] args) {

entier mois = 2 ;

int année = 2020 ;

int nombreJours = 0 ;

changer (mois) {

cas 1 : cas 3 : cas 5 :

cas 7 : cas 8 : cas 10 :

cas 12 :

nombreJours = 31 ;

Pause;

cas 4 : cas 6 :

cas 9 : cas 11 :

nombreJours = 30 ;

Pause;

cas 2 :

si (((année % 4 == 0) &&

!(année % 100 == 0))

|| (année % 400 == 0))

nombreJours = 29 ;

autre

nombreJours = 28 ;

Pause;

défaut:

System.out.println("Mois invalide.");

Pause;

}

System.out.println("Nombre de jours = "

+ nombreJours );

}

}

Sortir:

Nombre de jours = 29

Instructions de cas de commutation Java imbriquées

Un commutateur imbriqué est lorsque vous utilisez un commutateur dans le cadre de la séquence d'instructions d'un commutateur externe. Dans ce cas, il n'y a pas de conflit entre les constantes case de l'autre commutateur et celles du commutateur interne, car une instruction switch définit son propre bloc.

L'exemple suivant illustre l'utilisation d' instructions switch-case Java imbriquées :

classe publique TestNest {

public static void main(String[] args)

{

Branche de chaîne = "CSE" ;

int année = 2 ;

changer (année) {

cas 1:

System.out.println(“Cours au choix : Algèbre, Anglais avancé”);

Pause;

cas 2 :

switch (Branch) // switch imbriqué

{

cas « CSE » :

cas « CCE » :

System.out.println("Cours au choix : Big Data, Machine Learning");

Pause;

cas "ECE":

System.out.println("cours au choix : Ingénierie des Antennes");

Pause;

défaut:

System.out.println("Cours au choix : Optimisation");

}

}

}

}

Sortir:

Cours au choix : Big Data, Machine Learning

Utilisation de chaînes dans les instructions switch

À partir de JDK7, vous pouvez utiliser un objet String dans l'expression d'une instruction switch. La comparaison de l'objet chaîne dans l'expression de l'instruction switch avec les expressions associées de chaque étiquette de cas est comme si elle utilisait la méthode String.equals. En outre, la comparaison des objets chaîne dans l'expression de l'instruction switch est sensible à la casse.

L'exemple de code suivant affiche le type de jeu en fonction de la valeur de la chaîne nommée "game".

classe publique StringInSwitchStatementExample {

public static void main(String[] args) {

Jeu de cordes = "Cricket" ;

changer (jeu){

cas "Volleyball": cas "Football": cas "Cricket":

System.out.println("Ceci est un jeu de plein air");

Pause;

étui "Jeux de cartes": étui "Échecs": étui "Puzzles": étui "Basket-ball en salle":

System.out.println("Ceci est un jeu d'intérieur");

Pause;

défaut:

System.out.println("De quel jeu s'agit-il?");

}

}

}

Sortir:

Ceci est un jeu de plein air

Règles à retenir lors de l'utilisation des instructions de commutateur Java

Il serait préférable de garder certaines règles à l'esprit lors de l'utilisation des instructions de commutateur Java . Voici une liste des mêmes :

• La valeur d'un cas et la variable dans le commutateur doivent avoir le même type de données.
• Les instructions de commutateur Java n'autorisent pas les valeurs de casse en double.
• Une valeur de cas doit être littérale ou constante. Les variables ne sont pas autorisées.
• L'utilisation de l'instruction break à l'intérieur du commutateur met fin à une séquence d'instructions.
• L'instruction break est facultative et son omission continuera l'exécution dans le cas suivant.
• L'instruction par défaut est également facultative et peut apparaître n'importe où dans le bloc de commutateur. Si elle n'est pas placée à la fin, une instruction break doit être ajoutée après l'instruction par défaut pour ignorer l'exécution de l'instruction case suivante.

Aller de l'avant

Java a une popularité inégalée parmi les programmeurs et les développeurs et est l'un des langages de programmation les plus demandés aujourd'hui. Inutile de dire que les développeurs et ingénieurs logiciels en herbe qui souhaitent se perfectionner pour le marché du travail en constante évolution doivent maîtriser leurs compétences Java.

La certification PG liée à l'emploi d'upGrad en génie logiciel est spécialement conçue pour les étudiants de première année et les candidats de dernière année qui souhaitent apprendre à coder et être placés dans des rôles logiciels d'entrée de gamme.

Si vous vous demandez en quoi consiste le cours en ligne de 5 mois, voici quelques faits saillants pour vous donner une idée :

• Gagnez des spécialisations MERN Stack et Cloud-Native
• Apprenez les meilleures compétences comme les bases de données Java, DSA, CSS3, HTML5, AWS, MERN, SQL et NoSQL, et plus encore
• Plus de 500 heures de contenu avec plus de 350 heures de formation pratique
• Cinq projets industriels et plus de 50 sessions en direct
• Préparation au stage et orientation professionnelle
• Forums de discussion et solide réseau de pairs

Si vous souhaitez démarrer votre voyage vers une carrière prometteuse en génie logiciel, voici votre chance d'apprendre des meilleurs.