Der switch-Anweisung in Java ist eine Mehrwegverzweigungsanweisung. Vereinfacht ausgedrückt führt die Java-Switch-Anweisung eine Anweisung unter mehreren Bedingungen aus.

Es ist wie ein wenn-sonst-wenn Leiter-Anweisung. Es bietet eine einfache Möglichkeit, die Ausführung basierend auf dem Wert des Ausdrucks an verschiedene Teile des Codes zu verteilen. Der Ausdruck kann a sein Byte , kurz , verkohlen , oder int primitiver Datentyp. Es testet die Gleichheit von Variablen anhand mehrerer Werte.

Notiz: Der Java-Switch-Ausdruck muss aus Byte, Short, Int, Long (mit seinem Wrapper-Typ), Enumerationen und String bestehen. Ab JDK7 funktioniert es auch mit Aufzählungstypen ( Aufzählungen in Java), die Zeichenfolge Klasse, und Verpackung Klassen.

Syntax

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

Beispiel:

Beispiel für einen Größendrucker

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

Ausgabe:

Small>

Einige wichtige Regeln für Java Switch-Anweisungen

1. Es kann eine beliebige Anzahl von Fällen geben, in denen lediglich eine Bedingungsprüfung erforderlich ist. Beachten Sie jedoch, dass doppelte Fallwerte nicht zulässig sind.
2. Der Wert für einen Fall muss vom gleichen Datentyp sein wie die Variable im Schalter.
3. Der Wert für einen Fall muss konstant oder literal sein. Variablen sind nicht erlaubt.
4. Die break-Anweisung wird innerhalb des Schalters verwendet, um eine Anweisungssequenz zu beenden.
5. Die break-Anweisung ist optional. Wenn es weggelassen wird, wird die Ausführung mit dem nächsten Fall fortgesetzt.
6. Die Standardanweisung ist optional und kann an einer beliebigen Stelle im Switch-Block erscheinen. Falls es sich nicht am Ende befindet, muss nach der Standardanweisung eine Break-Anweisung eingehalten werden, um die Ausführung der nächsten Case-Anweisung zu unterlassen.

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

Flussdiagramm der Switch-Case-Anweisung

Dieses Flussdiagramm zeigt den Kontrollfluss und die Funktionsweise von Switch-Anweisungen:

Marquee-HTML

Notiz: Die Java-Switch-Anweisung ist eine Fall-Through-Anweisung, das heißt, sie führt alle if-Anweisungen aus Schlüsselwort break wird nicht verwendet, daher ist es äußerst wichtig, in jedem Fall das Schlüsselwort break zu verwenden.

Beispiel: Finding Day

Betrachten Sie das folgende Java-Programm. Es deklariert einen int mit dem Namen „day“, dessen Wert einen Tag (1-7) darstellt. Der Code zeigt mithilfe der switch-Anweisung den Namen des Tages basierend auf dem Wert des Tages an.

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

A break-Anweisung es ist optional. Wenn wir die Pause weglassen, wird die Ausführung mit dem nächsten Fall fortgesetzt.

Manchmal ist es wünschenswert, mehrere Fälle ohne zu haben brechen Aussagen zwischen ihnen. Betrachten wir beispielsweise die aktualisierte Version des obigen Programms. Sie zeigt auch an, ob ein Tag ein Wochentag oder ein Wochenendtag ist.

Beispiel:

Switch-Anweisungsprogramm ohne mehrere Pausen

Ausnahmebehandlung in Java auslösen

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

Java-verschachtelte Switch-Anweisungen

Wir können a verwenden schalten als Teil der Anweisungsfolge eines äußerer Schalter. Dies nennt man a verschachtelter Schalter . Da eine Switch-Anweisung ihren Block definiert, entstehen keine Konflikte zwischen den Case-Konstanten im inneren Switch und denen im äußeren Switch.

Beispiel:

Verschachtelte Switch-Anweisung

// 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 in der Switch-Anweisung

Aufzählungen (Enums) sind eine leistungsstarke und übersichtliche Möglichkeit stellen einen festen Satz benannter Konstanten dar in Java.

Aufzählungen werden aufgrund ihrer Typsicherheit und Lesbarkeit in Switch-Anweisungen verwendet.

Beispiel:

Verwendung von 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>

Standardanweisung im Java Switch Case

Der Standardfall im Switch-Fall gibt an, welcher Code ausgeführt werden soll, wenn kein Fall übereinstimmt.

Es wird bevorzugt, den Standardfall am Ende aller möglichen Fälle zu schreiben, er kann jedoch an jeder beliebigen Stelle in Switch-Anweisungen geschrieben werden.

Beispiel:

Standard in der Mitte von Switch-Anweisungen schreiben:

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

Beispiel:

Standard beim Schreiben von Switch-Anweisungen

TCP-IP-Modell

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>

Variationen der Falletiketten

Case-Label- und Switch-Argumente können ein konstanter Ausdruck sein. Das Argument switch kann ein variabler Ausdruck sein.

Beispiel:

Verwendung des variablen Schalterarguments.

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>

Eine Fallbezeichnung darf keine Variable oder kein Variablenausdruck sein. Es muss ein konstanter Ausdruck sein.

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 in Switch-Anweisungen

Java bietet vier davon Wrapper-Klassen Zu verwenden: Integer, Short, Byte und Long in Switch-Anweisungen.

Beispiel:

Java-Wrapper im Switch-Gehäuse.

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

Ausgabe:

You are 25.>

Notiz:

Unabhängig von seiner Platzierung wird der Standardfall nur ausgeführt, wenn keine der anderen Fallbedingungen erfüllt ist. Wenn Sie es also am Anfang, in der Mitte oder am Ende platzieren, ändert sich nichts an der Kernlogik (es sei denn, Sie verwenden eine weniger verbreitete Technik namens Fall-Through).

Beispiel: In diesem Code identifizieren wir den Wochentag durch (1-7) Zahlen.

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

Ausgabe

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

Mehr lesen:

Roboterkomponenten

• Verwendung von Enum- und Switch-Schlüsselwörtern in Java
• String im Switch-Gehäuse in Java
• Java-Tutorial

Übung

Um Java-Switch-Anweisungen zu üben, können Sie die Seite besuchen: Praxis für Java Switch Case-Anweisungen

Abschluss

Switch-Anweisungen in Java sind Kontrollflussstrukturen, die es Ihnen ermöglichen, bestimmte Codeblöcke basierend auf dem Wert eines einzelnen Ausdrucks auszuführen. Sie können als Alternative zu if-else-if-Anweisungen in der Programmierung betrachtet werden.

Java Switch-Anweisungen – FAQs

So verwenden Sie Switch-Anweisungen in Java

Um die Switch-Anweisung in Java zu verwenden, können Sie die folgende Syntax verwenden:

Schalter (Ausdruck) {
Fallwert1:
// Code, der ausgeführt werden soll, wenn Ausdruck gleich Wert1 ist
brechen;
Fallwert2:
// Code, der ausgeführt werden soll, wenn Ausdruck gleich Wert2 ist
brechen;
// … weitere Fälle
Standard:
// Code, der ausgeführt werden soll, wenn keiner der oben genannten Fälle zutrifft
}

Können wir null an einen Schalter übergeben?

Nein, Sie können NULL nicht an eine Switch-Anweisung übergeben, da diese in diesem Fall einen konstanten Ausdruck erfordert.

Können Sie zu einer switch-Anweisung zurückkehren?

Nein, Switch-Anweisungen bauen einen Kontrollfluss im Programm auf, sodass dieser nach Verlassen eines Switch-Falls nicht zurückgehen kann.