The instrukcja switch w Javie jest wielokierunkową instrukcją rozgałęzienia. Krótko mówiąc, instrukcja switch Java wykonuje jedną instrukcję na podstawie wielu warunków.

To jest jak jeśli-jeżeli-jeżeli oświadczenie drabinowe. Zapewnia łatwy sposób wysyłania wykonania do różnych części kodu w oparciu o wartość wyrażenia. Wyrażenie może mieć postać a bajt , krótki , zwęglać , Lub wew prymitywny typ danych. Testuje równość zmiennych względem wielu wartości.

Notatka: Wyrażenie przełącznika Java musi składać się z bajtu, krótkiego, int, długiego (wraz z typem Wrapper), wyliczeń i ciągu znaków. Począwszy od JDK7, działa również z typami wyliczeniowymi ( Wyliczenia w Javie), Strunowy klasa i Obwoluta zajęcia.

Składnia

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

Przykład:

Przykład drukarki rozmiaru

Java ma wartość zerową

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

Wyjście:

Small>

Kilka ważnych zasad dotyczących instrukcji Java Switch

1. Może istnieć dowolna liczba przypadków narzucających sprawdzenie warunku, ale pamiętaj, że zduplikowane wartości przypadków są niedozwolone.
2. Wartość przypadku musi być tego samego typu danych, co zmienna w przełączniku.
3. Wartość przypadku musi być stała lub dosłowna. Zmienne są niedozwolone.
4. Instrukcja break jest używana wewnątrz przełącznika w celu zakończenia sekwencji instrukcji.
5. Instrukcja break jest opcjonalna. Jeżeli zostanie pominięty, wykonanie będzie kontynuowane w następnej sprawie.
6. Instrukcja domyślna jest opcjonalna i może pojawić się w dowolnym miejscu bloku przełącznika. W przypadku, jeśli nie jest to koniec, to po instrukcji default należy umieścić instrukcję break, aby pominąć wykonanie kolejnej instrukcji 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.>

Schemat blokowy instrukcji dotyczącej przypadku zmiany

Poniższy schemat blokowy przedstawia przepływ sterowania i działanie instrukcji switch:

Notatka: Instrukcja switch Java jest instrukcją przejściową, co oznacza, że ​​wykonuje wszystkie instrukcje if przerwać słowo kluczowe nie jest używany, dlatego bardzo istotne jest użycie słowa kluczowego break w każdym przypadku.

Przykład: Dzień Znalezienia

Rozważmy następujący program Java, który deklaruje dzień o nazwie int, którego wartość reprezentuje dzień (1-7). Kod wyświetla nazwę dnia na podstawie wartości dnia za pomocą instrukcji 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 w instrukcjach switch case

A oświadczenie o złamaniu jest opcjonalne. Jeśli pominiemy przerwę, wykonanie będzie kontynuowane w następnym przypadku.

Czasami pożądane jest posiadanie wielu skrzynek bez nich przerwa wypowiedzi między nimi. Rozważmy na przykład zaktualizowaną wersję powyższego programu, wyświetla on również, czy dzień jest dniem powszednim, czy weekendem.

Przykład:

Program instrukcji przełączania bez wielokrotnych przerw

program do enkapsulacji

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

Instrukcje przełączników zagnieżdżonych w Javie

Możemy użyć A przełącznik Jak część sekwencji instrukcji z wyłącznik zewnętrzny. Nazywa się to przełącznik zagnieżdżony . Ponieważ instrukcja switch definiuje jej blok, nie powstają żadne konflikty pomiędzy stałymi wielkości liter w przełączniku wewnętrznym a stałymi w przełączniku zewnętrznym.

Przykład:

Zagnieżdżona instrukcja przełącznika

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

Wyliczenie Java w instrukcji Switch

Wyliczenia (wyliczenia) to skuteczny i przejrzysty sposób reprezentują ustalony zestaw nazwanych stałych w Jawie.

Wyliczenia są używane w instrukcjach Switch ze względu na ich bezpieczeństwo typu i czytelność.

Przykład:

Użycie Enum w Switchu

Java dodaj do tablicy

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

domyślna instrukcja w Java Switch Case

Domyślny przypadek w przypadku Switch określa, jaki kod ma zostać uruchomiony, jeśli żaden przypadek nie pasuje.

Preferowane jest zapisywanie przypadku domyślnego na końcu wszystkich możliwych przypadków, ale można go zapisać w dowolnym miejscu instrukcji switch.

Przykład:

Zapisywanie wartości domyślnej w środku instrukcji 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>

Przykład:

Zapisywanie wartości domyślnych na początku instrukcji 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>

Warianty etykiet etui

Etykieta przypadku i argumenty przełącznika mogą być wyrażeniem stałym. Argument switch może być wyrażeniem zmiennym.

Przykład:

Używanie argumentu zmiany zmiennej.

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>

Etykieta przypadku nie może być zmienną ani wyrażeniem zmiennym. Musi to być wyrażenie stałe.

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>

Opakowanie Java w instrukcjach Switch

Java zapewnia cztery klasy wrapperów do użycia: Integer, Short, Byte i Long w instrukcjach switch.

Przykład:

Opakowanie Java w obudowie przełącznika.

świetny język komputerowy

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

Wyjście:

You are 25.>

Notatka:

Niezależnie od jego umiejscowienia, przypadek domyślny zostanie wykonany tylko wtedy, gdy żaden z pozostałych warunków przypadku nie zostanie spełniony. Zatem umieszczenie go na początku, w środku lub na końcu nie zmienia podstawowej logiki (chyba że używasz mniej popularnej techniki zwanej opadaniem).

Przykład: W tym kodzie będziemy identyfikować dzień tygodnia za pomocą liczb (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;  }  } }>

Wyjście

ciąg do znaku Java

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

Czytaj więcej:

• Użycie słowa kluczowego Enum i Switch w Javie
• Ciąg znaków w Switch Case w Javie
• Samouczek Java

Ćwiczenia

Aby poćwiczyć instrukcje przełączania Java, możesz odwiedzić stronę: Praktyka dotycząca oświadczenia dotyczącego przypadku przełącznika Java

Wniosek

Instrukcje switch w Javie to struktury przepływu sterowania, które umożliwiają wykonanie określonego bloku kodu w oparciu o wartość pojedynczego wyrażenia. Można je traktować jako alternatywę dla instrukcji if-else-if w programowaniu.

Oświadczenia dotyczące przełącznika Java — często zadawane pytania

Jak używać instrukcji switch w Javie

Aby użyć instrukcji switch w Javie, możesz użyć następującej składni:

przełącznik (wyrażenie) {
wartość przypadku 1:
// kod do wykonania, jeśli wyrażenie ma wartość 1
przerwa;
wartość przypadku2:
// kod do wykonania, jeśli wyrażenie jest równe wartość2
przerwa;
//… więcej przypadków
domyślny:
// kod do wykonania, jeśli żaden z powyższych przypadków nie pasuje
}

Czy możemy przekazać wartość null do przełącznika

Nie, nie możesz przekazać NULL do instrukcji switch, ponieważ w jej przypadku wymagają one stałego wyrażenia.

Czy możesz wrócić do instrukcji switch

Nie, instrukcje switch budują przepływ sterowania w programie, więc nie można go cofnąć po wyjściu z przypadku przełącznika.