The instrucțiunea switch în Java este o declarație de ramură cu mai multe sensuri. Cu cuvinte simple, instrucțiunea Java switch execută o instrucțiune din mai multe condiții.

Este ca un dacă-altfel-dacă declarație de scară. Oferă o modalitate ușoară de a trimite execuția către diferite părți ale codului pe baza valorii expresiei. Expresia poate fi a octet , mic de statura , char , sau int tipul de date primitiv. Testează egalitatea variabilelor cu mai multe valori.

Notă: Expresia comutatorului Java trebuie să fie de octet, scurtă, int, lungă (cu tipul său Wrapper), enums și șir. Începând cu JDK7, funcționează și cu tipuri enumerate ( Enumări în java), the Şir clasa, si Înveliș clase.

Sintaxă

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

Exemplu:

Exemplu de imprimantă de dimensiune

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

Ieșire:

Small>

Câteva reguli importante pentru instrucțiunile Java Switch

1. Pot exista orice număr de cazuri care impun doar verificarea stării, dar nu uitați că nu sunt permise valori duplicate de cazuri.
2. Valoarea pentru un caz trebuie să fie de același tip de date ca și variabila din comutator.
3. Valoarea pentru un caz trebuie să fie constantă sau literală. Variabilele nu sunt permise.
4. Declarația break este utilizată în interiorul comutatorului pentru a termina o secvență de instrucțiuni.
5. Declarația break este opțională. Dacă este omisă, execuția va continua în cazul următor.
6. Declarația implicită este opțională și poate apărea oriunde în interiorul blocului de comutare. În caz, dacă nu este la sfârșit, atunci o instrucțiune break trebuie păstrată după instrucțiunea implicită pentru a omite execuția următoarei instrucțiuni 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 a declarației Switch-Case

Această diagramă de flux arată fluxul de control și funcționarea instrucțiunilor switch:

eroare de atribut python

Notă: Instrucțiunea Java switch este o instrucțiune fall through, ceea ce înseamnă că execută toate instrucțiunile if pauză cheie nu este utilizat, așa că este foarte esențial să utilizați cuvântul cheie break în fiecare caz.

îmbunătățit pentru buclă java

Exemplu: Ziua găsirii

Luați în considerare următorul program Java, acesta declară un int numit zi a cărui valoare reprezintă o zi (1-7). Codul afișează numele zilei, pe baza valorii zilei, folosind instrucțiunea 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 Declarații

A declarație de pauză este opțională. Dacă omitem pauză, execuția va continua în cazul următor.

Uneori este de dorit să existe mai multe cazuri fără pauză declarații între ei. De exemplu, să luăm în considerare versiunea actualizată a programului de mai sus, de asemenea, afișează dacă o zi este o zi lucrătoare sau o zi de weekend.

Exemplu:

Programul de instrucțiuni Switch fără mai multe pauze

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

Declarații de comutare imbricate Java

Putem folosi a intrerupator la fel de parte a secvenței de instrucțiuni a unui comutator exterior. Aceasta se numește a comutator imbricat . Deoarece o instrucțiune switch își definește blocul, nu apar conflicte între constantele caz din comutatorul interior și cele din comutatorul exterior.

Exemplu:

Declarație de comutare imbricată

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

Java Enum în instrucțiunea Switch

Enumerările (enumerările) sunt o modalitate puternică și clară de a reprezintă un set fix de constante numite în Java.

Enumerările sunt utilizate în instrucțiunile Switch datorită siguranței și lizibilității tipului lor.

Exemplu:

Utilizarea Enum în 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>

declarație implicită în Java Switch Case

cazul implicit în cazul Switch specifică ce cod să ruleze dacă niciun caz nu se potrivește.

Este de preferat să scrieți cazul implicit la sfârșitul tuturor cazurilor posibile, dar poate fi scris în orice loc în instrucțiunile switch.

superscript în ilustrator

Exemplu:

Scrierea implicită în mijlocul instrucțiunilor 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>

Exemplu:

Scrierea implicită la pornirea instrucțiunilor 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>

Variații ale etichetei cazului

Eticheta cazului și argumentele comutatoare pot fi o expresie constantă. Argumentul switch poate fi o expresie variabilă.

Exemplu:

Folosind argumentul comutator variabil.

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>

O etichetă de caz nu poate fi o variabilă sau o expresie variabilă. Trebuie să fie o expresie 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>

Java Wrapper în instrucțiuni Switch

Java oferă patru clase de ambalare de utilizat: Integer, Short, Byte și Long în instrucțiunile switch.

Exemplu:

Java Wrapper în carcasa comutatorului.

java int la char

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

Ieșire:

You are 25.>

Notă:

Indiferent de plasarea sa, cazul implicit este executat numai dacă nici una dintre celelalte condiții de caz nu este îndeplinită. Așadar, punerea lui la început, la mijloc sau la sfârșit nu schimbă logica de bază (cu excepția cazului în care utilizați o tehnică mai puțin obișnuită numită cădere).

Exemplu: În acest cod vom identifica ziua săptămânii prin numere (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;  }  } }>

Ieșire

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

Citeşte mai mult:

coada in java

• Utilizarea Enum și Switch Keyword în Java
• String în Switch Case în Java
• Tutorial Java

Exercițiu

Pentru a exersa instrucțiunile de comutare Java, puteți vizita pagina: Declarație Java Switch Case Practică

Concluzie

Instrucțiunile Switch în Java sunt structuri de flux de control, care vă permit să executați un anumit bloc de cod pe baza valorii unei singure expresii. Ele pot fi considerate ca o alternativă la instrucțiunile if-else-if în programare.

Declarații Java Switch- Întrebări frecvente

Cum să utilizați instrucțiunile switch în Java

Pentru a utiliza instrucțiunea switch în Java, puteți utiliza următoarea sintaxă:

comuta (expresie) {
valoare caz 1:
// cod de executat dacă expresia este egală cu valoarea1
pauză;
valoarea cazului 2:
// cod de executat dacă expresia este egală cu valoarea2
pauză;
// … mai multe cazuri
Mod implicit:
// cod de executat dacă niciunul dintre cazurile de mai sus nu se potrivește
}

Putem trece nul la un comutator

Nu, nu puteți trece NULL unei instrucțiuni switch deoarece necesită o expresie constantă în cazul acesteia.

Puteți reveni la o declarație switch

Nu, instrucțiunile switch construiesc un flux de control în program, așa că nu se poate întoarce după ieșirea dintr-un caz de comutare.