Le instruction de commutation en Java est une instruction de branchement multidirectionnel. En termes simples, l'instruction Java switch exécute une instruction à partir de plusieurs conditions.

C'est comme un si-sinon-si déclaration d'échelle. Il fournit un moyen simple de répartir l’exécution vers différentes parties du code en fonction de la valeur de l’expression. L'expression peut être un octet , court , carboniser , ou int type de données primitif. Il teste l'égalité des variables par rapport à plusieurs valeurs.

Note: L'expression du commutateur Java doit être de type octet, court, entier, long (avec son type Wrapper), énumération et chaîne. Depuis JDK7, il fonctionne également avec les types énumérés ( Énumérations en java), le Chaîne classe, et Emballage Des classes.

Syntaxe

switch(expression) {  case value1 :  // Statements  break; // break is optional    case value2 :  // Statements  break; // break is optional  ....  ....  ....  default :   // default Statement }>

Exemple:

Exemple d'imprimante de taille

tri par insertion Java

public class SizePrinter {  public static void main(String[] args) {  int sizeNumber = 2; // Replace with your desired size (1, 2, 3, 4, or 5)  switch (sizeNumber) {  case 1:  System.out.println('Extra Small');  break;  case 2:  System.out.println('Small');  break;  case 3:  System.out.println('Medium');  break;  case 4:  System.out.println('Large');  break;  case 5:  System.out.println('Extra Large');  break;  default:  System.out.println('Invalid size number');  }  } }>

Sortir:

Small>

Quelques règles importantes pour les instructions Java Switch

1. Il peut y avoir un certain nombre de cas imposant simplement une vérification de condition, mais rappelez-vous que les valeurs de cas en double ne sont pas autorisées.
2. La valeur d'un cas doit être du même type de données que la variable du commutateur.
3. La valeur d'un cas doit être constante ou littérale. Les variables ne sont pas autorisées.
4. L'instruction break est utilisée à l'intérieur du commutateur pour terminer une séquence d'instructions.
5. L'instruction break est facultative. En cas d'omission, l'exécution se poursuivra dans le cas suivant.
6. L'instruction par défaut est facultative et peut apparaître n'importe où dans le bloc switch. Dans le cas contraire, une instruction break doit être conservée après l'instruction par défaut pour omettre l'exécution de l'instruction case suivante.

  Note: Until Java-6, switch case argument cannot be of String type but Java 7 onward we can use String type argument in Switch Case.>

Organigramme de la déclaration Switch-Case

Cet organigramme montre le flux de contrôle et le fonctionnement des instructions switch :

Note: L'instruction Java switch est une instruction de transition qui signifie qu'elle exécute toutes les instructions si casser le mot-clé n'est pas utilisé, il est donc hautement essentiel d'utiliser le mot-clé break dans chaque cas.

Exemple: Journée de découverte

Considérez le programme Java suivant, il déclare un int nommé day dont la valeur représente un jour (1-7). Le code affiche le nom du jour, en fonction de la valeur du jour, à l'aide de l'instruction switch.

// Java program to Demonstrate Switch Case // with Primitive(int) Data Type // Class public class GFG {  // Main driver method  public static void main(String[] args)  {  int day = 5;  String dayString;  // Switch statement with int data type  switch (day) {  // Case  case 1:  dayString = 'Monday';  break;  // Case  case 2:  dayString = 'Tuesday';  break;  // Case  case 3:  dayString = 'Wednesday';  break;  // Case  case 4:  dayString = 'Thursday';  break;  // Case  case 5:  dayString = 'Friday';  break;  // Case  case 6:  dayString = 'Saturday';  break;  // Case  case 7:  dayString = 'Sunday';  break;  // Default case  default:  dayString = 'Invalid day';  }  System.out.println(dayString);  } }>

Friday>

rupture dans le boîtier de commutation

UN instruction de pause est facultatif. Si nous omettons la pause, l'exécution se poursuivra dans le cas suivant.

Il est parfois souhaitable d'avoir plusieurs cas sans casser déclarations entre eux. Par exemple, considérons la version mise à jour du programme ci-dessus, elle affiche également si un jour est un jour de semaine ou un jour de week-end.

Exemple:

Programme d'instruction Switch sans plusieurs pauses

c++ convertir un entier en chaîne

// Java Program to Demonstrate Switch Case // with Multiple Cases Without Break Statements // Class public class GFG {  // main driver method  public static void main(String[] args)  {  int day = 2;  String dayType;  String dayString;  // Switch case  switch (day) {  // Case  case 1:  dayString = 'Monday';  break;  // Case  case 2:  dayString = 'Tuesday';  break;  // Case  case 3:  dayString = 'Wednesday';  break;  case 4:  dayString = 'Thursday';  break;  case 5:  dayString = 'Friday';  break;  case 6:  dayString = 'Saturday';  break;  case 7:  dayString = 'Sunday';  break;  default:  dayString = 'Invalid day';  }  switch (day) {  // Multiple cases without break statements  case 1:  case 2:  case 3:  case 4:  case 5:  dayType = 'Weekday';  break;  case 6:  case 7:  dayType = 'Weekend';  break;  default:  dayType = 'Invalid daytype';  }  System.out.println(dayString + ' is a ' + dayType);  } }>

Tuesday is a Weekday>

Instructions de commutateur imbriquées Java

Nous pouvons utiliser un changer comme partie de la séquence d'instructions d'un interrupteur extérieur. C'est ce qu'on appelle un commutateur imbriqué . Puisqu'une instruction switch définit son bloc, aucun conflit ne survient entre les constantes de cas du commutateur interne et celles du commutateur externe.

Exemple:

Instruction de commutateur imbriquée

// Java Program to Demonstrate // Nested Switch Case Statement // Class public class GFG {  // Main driver method  public static void main(String[] args)  {  // Custom input string  String Branch = 'CSE';  int year = 2;  // Switch case  switch (year) {  // Case  case 1:  System.out.println(  'elective courses : Advance english, Algebra');  // Break statement to hault execution here  // itself if case is matched  break;  // Case  case 2:  // Switch inside a switch  // Nested Switch  switch (Branch) {  // Nested case  case 'CSE':  case 'CCE':  System.out.println(  'elective courses : Machine Learning, Big Data');  break;  // Case  case 'ECE':  System.out.println(  'elective courses : Antenna Engineering');  break;  // default case  // It will execute if above cases does not  // execute  default:  // Print statement  System.out.println(  'Elective courses : Optimization');  }  }  } }>

elective courses : Machine Learning, Big Data>

Énumération Java dans l'instruction Switch

Les énumérations (énumérations) sont un moyen puissant et clair de représente un ensemble fixe de constantes nommées en Java.

Les énumérations sont utilisées dans les instructions Switch en raison de leur sécurité de type et de leur lisibilité.

Exemple:

Utilisation d'Enum dans Switch

kylie jenner âge

// Java Program to Illustrate Use of Enum // in Switch Statement // Class public class GFG {  // Enum  public enum Day { Sun, Mon, Tue, Wed, Thu, Fri, Sat }  // Main driver method  public static void main(String args[])  {  // Enum  Day[] DayNow = Day.values();  // Iterating using for each loop  for (Day Now : DayNow) {  // Switch case  switch (Now) {  // Case 1  case Sun:  System.out.println('Sunday');  // break statement that hault further  // execution once case is satisfied  break;  // Case 2  case Mon:  System.out.println('Monday');  break;  // Case 3  case Tue:  System.out.println('Tuesday');  break;  // Case 4  case Wed:  System.out.println('Wednesday');  break;  // Case 5  case Thu:  System.out.println('Thursday');  break;  // Case 6  case Fri:  System.out.println('Friday');  break;  // Case 7  case Sat:  System.out.println('Saturday');  }  }  } }>

Sunday Monday Tuesday Wednesday Thursday Friday Saturday>

instruction par défaut dans le cas Java Switch

le cas par défaut dans le cas Switch spécifie le code à exécuter si aucun cas ne correspond.

Il est préférable d'écrire le cas par défaut à la fin de tous les cas possibles, mais il peut être écrit à n'importe quel endroit dans les instructions switch.

Exemple:

Écrire default au milieu des instructions switch :

/*package whatever //do not write package name here */ import java.io.*; class GFG {  public static void main (String[] args) {  int i=2;  switch(i){  default:  System.out.println('Default');  case 1:  System.out.println(1);  break;  case 2:  System.out.println(2);  case 3:  System.out.println(3);    }  } }>

2 3>

Exemple:

Écriture par défaut au début des instructions switch

import java.io.*; class GFG {  public static void main(String[] args)  {  int i = 5;  switch (i) {  default:  System.out.println('Default');  case 1:  System.out.println(1);  break;  case 2:  System.out.println(2);  case 3:  System.out.println(3);  }  } }>

Default 1>

Variations des étiquettes de caisse

Les arguments d’étiquette de cas et de commutateur peuvent être une expression constante. L'argument switch peut être une expression variable.

Exemple:

Utilisation de l'argument de commutateur variable.

import java.io.*; class GFG {  public static void main(String[] args)  {  int x = 2;  switch (x + 1) {  case 1:  System.out.println(1);  break;  case 1 + 1:  System.out.println(2);  break;  case 2 + 1:  System.out.println(3);  break;  default:  System.out.println('Default');  }  } }>

3>

Une étiquette de cas ne peut pas être une variable ou une expression variable. Ce doit être une expression constante.

import java.io.*; class GFG {  public static void main(String[] args)  {  int x = 2;  int y = 1;  switch (x) {  case 1:  System.out.println(1);  break;  case 2:  System.out.println(2);  break;  case x + y:  System.out.println(3);  break;  default:  System.out.println('Default');  }  } }>

./GFG.java:16: error: constant expression required  case x+y:  ^ 1 error>

Wrapper Java dans les instructions Switch

Java fournit quatre cours d'emballage à utiliser : Integer, Short, Byte et Long dans les instructions switch.

Exemple:

Java Wrapper dans le boîtier du commutateur.

variable bash

public class WrapperSwitchExample {  public static void main(String[] args) {  Integer age = 25;  switch (age.intValue()) { // Extract primitive value for switch  case 25:  System.out.println('You are 25.');  break;  case 30:  System.out.println('You are 30.');  break;  default:  System.out.println('Age not matched.');  }  } }>

Sortir:

You are 25.>

Note:

Quel que soit son emplacement, le cas par défaut n'est exécuté que si aucune des autres conditions du cas n'est remplie. Ainsi, le placer au début, au milieu ou à la fin ne change pas la logique de base (sauf si vous utilisez une technique moins courante appelée fall-through).

Exemple : Dans ce code, nous identifierons le jour de la semaine grâce à des chiffres (1-7).

import java.util.Scanner; public class Main {  public static void main(String[] args) {  Scanner scanner = new Scanner(System.in);  System.out.print('Enter a day number (1-7): ');  int day = scanner.nextInt();  switch (day) {  default:  System.out.println('Not a valid weekday.');  break;  case 1:  System.out.println('It's Monday!');  break;  case 2:  System.out.println('It's Tuesday!');  break;  case 3:  System.out.println('It's Wednesday!');  break;  case 4:  System.out.println('It's Thursday!');  break;  case 5:  System.out.println('It's Friday!');  break;  case 6:  System.out.println('It's Saturday!');  break;  case 7:  System.out.println('It's Sunday!');  break;  }  } }>

Sortir

valeur de la chaîne

Enter a day number (1-7): 8 Not a valid weekday.>

En savoir plus:

• Utilisation des mots-clés Enum et Switch en Java
• Chaîne dans le cas Switch en Java
• Tutoriel Java

Exercice

Pour pratiquer les instructions Java switch, vous pouvez visiter la page : Pratique de l'instruction Java Switch Case

Conclusion

Les instructions Switch en Java sont des structures de flux de contrôle qui vous permettent d'exécuter certains blocs de code en fonction de la valeur d'une seule expression. Ils peuvent être considérés comme une alternative aux instructions if-else-if en programmation.

Déclarations Java Switch - FAQ

Comment utiliser les instructions switch en Java

Pour utiliser l'instruction switch en Java, vous pouvez utiliser la syntaxe suivante :

changer (expression) {
valeur de cas1 :
// code à exécuter si l'expression est égale à valeur1
casser;
valeur de cas2 :
// code à exécuter si l'expression est égale à valeur2
casser;
// … plus de cas
défaut:
// code à exécuter si aucun des cas ci-dessus ne correspond
}

Pouvons-nous passer null à un commutateur

Non, vous ne pouvez pas transmettre NULL à une instruction switch car elle nécessite une expression constante dans son cas.

Pouvez-vous revenir à une instruction switch

Non, les instructions switch créent un flux de contrôle dans le programme, il ne peut donc pas revenir en arrière après avoir quitté un cas de commutation.