Det switch statement i Java er en multi-way branch statement. Med enkle ord udfører Java switch-sætningen én sætning fra flere forhold.

Det er ligesom en hvis-andet-hvis stigeerklæring. Det giver en nem måde at sende udførelse til forskellige dele af koden baseret på værdien af ​​udtrykket. Udtrykket kan være en byte , kort , char , eller int primitiv datatype. Det tester ligheden af ​​variabler mod flere værdier.

Bemærk: Java switch-udtryk skal være af byte, short, int, long (med sin Wrapper-type), enums og streng. Begyndende med JDK7 fungerer det også med opregnede typer ( Enums i java), den Snor klasse, og Indpakning klasser.

Syntaks

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

Eksempel:

Eksempel på printerstørrelse

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

Produktion:

Small>

Nogle vigtige regler for Java Switch-udsagn

1. Der kan være et hvilket som helst antal sager, der bare pålægger tilstandskontrol, men husk at duplikerede sagsværdier ikke er tilladt.
2. Værdien for en sag skal være af samme datatype som variablen i switchen.
3. Værdien for en sag skal være konstant eller bogstavelig. Variabler er ikke tilladt.
4. Pause-sætningen bruges inde i switchen til at afslutte en sætningssekvens.
5. Pauseerklæringen er valgfri. Hvis den udelades, vil eksekveringen fortsætte til næste sag.
6. Standardsætningen er valgfri og kan vises hvor som helst inde i switch-blokken. I tilfældet, hvis det ikke er i slutningen, skal der opbevares en break-erklæring efter standardsætningen for at udelade udførelsen af ​​den næste case-sætning.

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

Flowchart af Switch-Case Statement

Dette rutediagram viser kontrolflowet og funktion af switch-udsagn:

Bemærk: Java switch-sætning er en fall-through-sætning, der betyder, at den udfører alle sætninger if bryde søgeord bruges ikke, så det er meget vigtigt at bruge break søgeord i hvert enkelt tilfælde.

kali linux kommandoer

Eksempel: Findedag

Overvej følgende Java-program, det erklærer en int navngivet dag, hvis værdi repræsenterer en dag(1-7). Koden viser navnet på dagen, baseret på dagens værdi, ved hjælp af switch-sætningen.

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

brud i afbryderkasse Udsagn

EN pauseerklæring er valgfrit. Hvis vi udelader pausen, fortsætter eksekveringen til næste sag.

Det er nogle gange ønskeligt at have flere sager uden pause udsagn mellem dem. Lad os for eksempel overveje den opdaterede version af ovenstående program, det viser også, om en dag er en hverdag eller en weekenddag.

Eksempel:

Skift udsagnsprogram uden flere pauser

// 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 Nested Switch Statements

Vi kan bruge en kontakt som del af udsagnssekvensen af en ydre kontakt. Dette kaldes en indlejret kontakt . Da en switch-sætning definerer sin blok, opstår der ingen konflikter mellem case-konstanterne i den indre switch og dem i den ydre switch.

Eksempel:

Indlejret switch-erklæring

// 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 i Switch Statement

Optællinger (enumer) er en kraftfuld og overskuelig måde at repræsentere et fast sæt af navngivne konstanter i Java.

Enums bruges i Switch-udsagn på grund af deres typesikkerhed og læsbarhed.

Eksempel:

Brug af Enum i 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>

standarderklæring i Java Switch Case

standard-case i Switch-tilfældet angiver, hvilken kode der skal køres, hvis ingen case matcher.

Det foretrækkes at skrive standardcasus i slutningen af ​​alle mulige sager, men den kan skrives hvor som helst i switch-sætninger.

Eksempel:

Skrivning som standard i midten af ​​switch-sætninger:

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

Eksempel:

Skrivning som standard ved start af switch-sætninger

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>

Variationer af æskeetiketter

Sagsbetegnelse og skiftargumenter kan være et konstant udtryk. Switch-argumentet kan være et variabelt udtryk.

Eksempel:

Brug af variabelt skifteargument.

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>

En kasusetiket kan ikke være et variabelt eller variabelt udtryk. Det skal være et konstant udtryk.

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 i Switch Statements

Java giver fire indpakningsklasser at bruge: Integer, Short, Byte og Long i switch-sætninger.

Eksempel:

Java Wrapper i switch case.

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

Produktion:

java int til char

You are 25.>

Bemærk:

Uanset dens placering, bliver standardsagen kun eksekveret, hvis ingen af ​​de andre sagsbetingelser er opfyldt. Så at sætte det i begyndelsen, midten eller slutningen ændrer ikke kernelogikken (medmindre du bruger en mindre almindelig teknik kaldet gennemfald).

Eksempel: I denne kode identificerer vi ugedagen gennem (1-7) numre.

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

Produktion

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

Læs mere:

• Brug af Enum og Switch Keyword i Java
• String i Switch Case i Java
• Java tutorial

Dyrke motion

For at øve Java switch-sætninger kan du besøge siden: Java Switch Case statement Praksis

Konklusion

Switch-sætninger i Java er kontrolflowstrukturer, der giver dig mulighed for at udføre en bestemt kodeblok baseret på værdien af ​​et enkelt udtryk. De kan betragtes som et alternativ til if-else-if-udsagn i programmering.

Java Switch-erklæringer - ofte stillede spørgsmål

Sådan bruger du switch-sætninger i Java

For at bruge switch-sætning i Java kan du bruge følgende syntaks:

switch (udtryk) {
case værdi1:
// kode, der skal udføres, hvis udtryk er lig med værdi1
pause;
case værdi2:
// kode, der skal udføres, hvis udtryk er lig med værdi2
pause;
// … flere sager
Standard:
// kode til at udføre, hvis ingen af ​​ovenstående tilfælde matcher
}

Kan vi overføre nul til en switch

Nej, du kan ikke sende NULL til en switch-sætning, da de kræver konstant udtryk i dens tilfælde.

Kan du vende tilbage til en switch-erklæring

Nej, switch-sætninger bygger et kontrolflow i programmet, så det kan ikke gå tilbage efter at have afsluttet en switch-case.