IL istruzione switch in Java è un'istruzione di ramo a più vie. In parole semplici, l'istruzione switch Java esegue un'istruzione da più condizioni.

È come un se-altro-se dichiarazione della scala. Fornisce un modo semplice per inviare l'esecuzione a diverse parti del codice in base al valore dell'espressione. L'espressione può essere a byte , corto , car , O int tipo di dati primitivo. Verifica l'uguaglianza delle variabili rispetto a più valori.

Nota: L'espressione switch Java deve essere di byte, short, int, long (con il relativo tipo Wrapper), enumerazioni e string. A partire da JDK7, funziona anche con i tipi enumerati ( Enumerazioni in Java), il Corda classe e Involucro classi.

Sintassi

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

Esempio:

Esempio di stampante di dimensioni

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

Produzione:

Small>

Alcune regole importanti per le istruzioni Java Switch

1. Può esserci un numero qualsiasi di casi che impongono semplicemente il controllo delle condizioni, ma ricorda che non sono consentiti valori di casi duplicati.
2. Il valore di un caso deve essere dello stesso tipo di dati della variabile nello switch.
3. Il valore di un caso deve essere costante o letterale. Le variabili non sono consentite.
4. L'istruzione break viene utilizzata all'interno dello switch per terminare una sequenza di istruzioni.
5. L'istruzione break è facoltativa. Se omesso, l'esecuzione continuerà nel caso successivo.
6. L'istruzione default è facoltativa e può apparire ovunque all'interno del blocco switch. Nel caso in cui non sia alla fine, è necessario mantenere un'istruzione break dopo l'istruzione default per omettere l'esecuzione della successiva istruzione 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.>

Diagramma di flusso della dichiarazione Switch-Case

Questo diagramma di flusso mostra il flusso di controllo e il funzionamento delle istruzioni switch:

Nota: L'istruzione switch Java è un'istruzione fall through, ovvero esegue tutte le istruzioni if interrompere la parola chiave non viene utilizzato, quindi è estremamente essenziale utilizzare la parola chiave break all'interno di ciascun caso.

Esempio: Giorno della ricerca

Considera il seguente programma Java, dichiara un int denominato day il cui valore rappresenta un giorno (1-7). Il codice visualizza il nome del giorno, in base al valore del giorno, utilizzando l'istruzione 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 Statements

UN interrompere l'istruzione è facoltativo. Se omettiamo l'interruzione, l'esecuzione continuerà nel caso successivo.

A volte è desiderabile avere più casi senza rottura dichiarazioni tra di loro. Ad esempio, consideriamo la versione aggiornata del programma sopra, che mostra anche se un giorno è un giorno feriale o un giorno festivo.

Esempio:

Cambia programma di istruzioni senza interruzioni multiple

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

Istruzioni di commutazione nidificate Java

Possiamo usare a interruttore COME parte della sequenza di istruzioni di un interruttore esterno. Questo è chiamato a interruttore nidificato . Poiché un'istruzione switch definisce il suo blocco, non si verificano conflitti tra le costanti case nello switch interno e quelle nello switch esterno.

modello ip tcp

Esempio:

Istruzione Switch nidificata

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

Enumerazione Java nell'istruzione Switch

Le enumerazioni (enumerazioni) sono un modo potente e chiaro per rappresentano un insieme fisso di costanti denominate a Giava.

Le enumerazioni vengono utilizzate nelle istruzioni Switch a causa della loro indipendenza dal tipo e leggibilità.

Esempio:

Utilizzo di Enum in 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>

istruzione predefinita in Java Switch Case

il caso predefinito nel caso Switch specifica quale codice eseguire se nessun caso corrisponde.

È preferibile scrivere il caso predefinito alla fine di tutti i casi possibili, ma può essere scritto in qualsiasi punto delle istruzioni switch.

Esempio:

Scrittura di default nel mezzo delle istruzioni 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>

Esempio:

Scrittura di default all'inizio delle istruzioni 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>

Variazioni dell'etichetta del caso

L'etichetta Case e gli argomenti switch possono essere un'espressione costante. L'argomento switch può essere un'espressione variabile.

Esempio:

Utilizzando l'argomento del cambio variabile.

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>

Un'etichetta di caso non può essere una variabile o un'espressione variabile. Deve essere un'espressione costante.

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 nelle istruzioni Switch

Java ne fornisce quattro classi wrapper da utilizzare: Integer, Short, Byte e Long nelle istruzioni switch.

lunghezza della stringa Java

Esempio:

Wrapper Java nella custodia dell'interruttore.

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

Produzione:

You are 25.>

Nota:

Indipendentemente dal suo posizionamento, il caso predefinito viene eseguito solo se nessuna delle altre condizioni del caso viene soddisfatta. Quindi, inserirlo all'inizio, al centro o alla fine non cambia la logica di base (a meno che non si utilizzi una tecnica meno comune chiamata fall-through).

Esempio: In questo codice identificheremo il giorno della settimana tramite i numeri (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;  }  } }>

Produzione

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

Per saperne di più:

• Utilizzo di Enum e Switch Keyword in Java
• Stringa in Switch Case in Java
• Tutorial Java

Esercizio

Per esercitarti nelle istruzioni switch Java puoi visitare la pagina: Pratica sull'istruzione Java Switch Case

Conclusione

Le istruzioni Switch in Java sono strutture di flusso di controllo che consentono di eseguire determinati blocchi di codice in base al valore di una singola espressione. Possono essere considerati un'alternativa alle istruzioni if-else-if nella programmazione.

Dichiarazioni sullo switch Java: domande frequenti

Come utilizzare le istruzioni switch in Java

Per utilizzare l'istruzione switch in Java, è possibile utilizzare la seguente sintassi:

interruttore (espressione) {
valore caso1:
// codice da eseguire se espressione è uguale a valore1
rottura;
valore caso2:
// codice da eseguire se espressione è uguale a valore2
rottura;
// … altri casi
predefinito:
// codice da eseguire se nessuno dei casi precedenti corrisponde
}

Possiamo passare null a uno switch

No, non puoi passare NULL a un'istruzione switch poiché nel suo caso richiedono un'espressione costante.

Puoi tornare a un'istruzione switch

No, le istruzioni switch creano un flusso di controllo nel programma, quindi non può tornare indietro dopo essere usciti da un caso switch.