El declaració switch en Java és una declaració de branca multidireccional. En paraules senzilles, la instrucció de commutació de Java executa una sentència a partir de diverses condicions.

És com un si-una altra cosa-si declaració d'escala. Proporciona una manera senzilla d'enviar l'execució a diferents parts del codi en funció del valor de l'expressió. L'expressió pot ser a byte , curt , char , o int tipus de dades primitius. Comprova la igualtat de variables amb diversos valors.

Nota: L'expressió de commutació de Java ha de ser de byte, curta, int, llarga (amb el seu tipus Wrapper), enumeracions i cadena. Començant amb JDK7, també funciona amb tipus enumerats ( enumeracions en java), el Corda classe, i Embolcall classes.

Sintaxi

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

Exemple:

Exemple d'impressora de mida

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');  }  } }>

Sortida:

Small>

Algunes regles importants per a les declaracions de commutació de Java

1. Hi pot haver qualsevol nombre de casos que només imposen la comprovació de les condicions, però recordeu que no es permeten els valors de casos duplicats.
2. El valor d'un cas ha de ser del mateix tipus de dades que la variable del commutador.
3. El valor d'un cas ha de ser constant o literal. No es permeten les variables.
4. La instrucció break s'utilitza dins del commutador per finalitzar una seqüència d'instruccions.
5. La declaració break és opcional. Si s'omet, l'execució continuarà en el cas següent.
6. La declaració per defecte és opcional i pot aparèixer a qualsevol lloc dins del bloc switch. En cas, si no és al final, s'ha de mantenir una instrucció break després de la instrucció predeterminada per ometre l'execució de la següent instrucció case.

  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.>

Diagrama de flux de la declaració del cas de commutació

Aquest diagrama de flux mostra el flux de control i el funcionament de les declaracions de commutació:

Nota: La declaració de commutació de Java és una declaració de caiguda que significa que executa totes les instruccions si la paraula clau trenca no s'utilitza, per la qual cosa és molt essencial utilitzar la paraula clau break dins de cada cas.

fonts per a gimp

Exemple: Dia de la Trobada

Considereu el següent programa Java, declara un dia amb nom int el valor del qual representa un dia (1-7). El codi mostra el nom del dia, en funció del valor del dia, mitjançant la instrucció 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>

break in switch case declaracions

A declaració de ruptura és opcional. Si ometem el trencament, l'execució continuarà en el següent cas.

De vegades és desitjable tenir múltiples casos sense trencar declaracions entre ells. Per exemple, considerem la versió actualitzada del programa anterior, també mostra si un dia és un dia laborable o un dia de cap de setmana.

Exemple:

Programa de declaracions de canvi sense múltiples pauses

// 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>

Declaracions de commutació anidades de Java

Podem utilitzar a interruptor com part de la seqüència d'enunciats D'un interruptor exterior. Això s'anomena a interruptor imbricat . Com que una instrucció switch defineix el seu bloc, no sorgeixen conflictes entre les constants de cas de l'interruptor intern i les de l'interruptor extern.

Exemple:

Declaració de commutació niuada

// 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>

Enumeració Java a la declaració Switch

Les enumeracions (enums) són una manera potent i clara de fer-ho representen un conjunt fix de constants anomenades en Java.

què és maven

Les enumeracions s'utilitzen a les declaracions Switch a causa del seu tipus de seguretat i llegibilitat.

Exemple:

Ús de Enum a Switch

// 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>

declaració predeterminada a Java Switch Case

La majúscula predeterminada a la majúscula Switch especifica quin codi s'ha d'executar si no coincideix cap cas.

Es prefereix escriure el cas predeterminat al final de tots els casos possibles, però es pot escriure en qualsevol lloc de les sentències switch.

Exemple:

Escriptura per defecte al mig de les declaracions 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:

Escriptura predeterminada a l'inici de les declaracions 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>

Variacions d'etiquetes de caixa

L'etiqueta de cas i els arguments de canvi poden ser una expressió constant. L'argument switch pot ser una expressió variable.

Exemple:

Utilitzant l'argument de commutació 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>

Una etiqueta de cas no pot ser una variable o una expressió variable. Ha de ser una expressió constant.

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>

Embolcall de Java a les declaracions de commutació

Java en proporciona quatre classes d'embolcall utilitzar: Enter, Short, Byte i Long en declaracions switch.

variable de referència en java

Exemple:

Embolcall de Java a la caixa de l'interruptor.

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.');  }  } }>

Sortida:

You are 25.>

Nota:

Independentment de la seva ubicació, el cas per defecte només s'executa si no es compleix cap de les altres condicions del cas. Per tant, posar-lo al principi, al mig o al final no canvia la lògica bàsica (tret que utilitzeu una tècnica menys comuna anomenada caiguda).

Exemple: En aquest codi identificarem el dia feiner a través dels números (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;  }  } }>

Sortida

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

Llegeix més:

• Ús de la paraula clau Enum i Switch a Java
• Cadena a Switch Case a Java
• Tutorial de Java

Exercici

Per practicar les declaracions de commutació de Java, podeu visitar la pàgina: Java Switch Case declaració Pràctica

Conclusió

Les sentències de commutació a Java són estructures de flux de control, que us permeten executar determinats blocs de codi basats en el valor d'una sola expressió. Es poden considerar com una alternativa a les declaracions if-else-if a la programació.

Declaracions de commutació de Java: preguntes freqüents

Com utilitzar les declaracions switch a Java

Per utilitzar la instrucció switch a Java, podeu utilitzar la sintaxi següent:

canviar (expressió) {
valor de cas 1:
// codi per executar si l'expressió és igual a valor1
trencar;
valor de cas 2:
// codi per executar si l'expressió és igual a valor2
trencar;
// … més casos
per defecte:
// codi per executar si cap dels casos anteriors coincideix
}

Podem passar nul a un interruptor

No, no podeu passar NULL a una instrucció switch, ja que requereixen una expressió constant en el seu cas.

Pots tornar a una declaració switch

No, les declaracions de commutació creen un flux de control al programa, de manera que no pot tornar enrere després de sortir d'un cas de commutació.