De switch-sats i Java är ett multi-way branch statement. Med enkla ord, Java switch-satsen kör en sats från flera villkor.
Det är som en om-annat-om stege uttalande. Det ger ett enkelt sätt att skicka exekvering till olika delar av koden baserat på uttryckets värde. Uttrycket kan vara en byte , kort , röding , eller int primitiv datatyp. Den testar variablernas likhet mot flera värden.
Notera: Java-växlingsuttryck måste vara av byte, short, int, long (med dess Wrapper-typ), enums och sträng. Från och med JDK7 fungerar det också med uppräknade typer ( Enums i java), den Sträng klass, och Omslag klasser.
Syntax
switch(expression) { case value1 : // Statements break; // break is optional case value2 : // Statements break; // break is optional .... .... .... default : // default Statement }>Exempel:
Exempel på skrivarstorlek
Java 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>
Några viktiga regler för Java Switch-utlåtanden
- Det kan finnas hur många fall som helst som bara kräver tillståndskontroll, men kom ihåg att dubbla fall/värden inte är tillåtna.
- Värdet för ett fall måste vara av samma datatyp som variabeln i switchen.
- Värdet för ett fall måste vara konstant eller bokstavligt. Variabler är inte tillåtna.
- Break-satsen används inuti switchen för att avsluta en satssekvens.
- Paussatsen är valfri. Om det utelämnas kommer exekveringen att fortsätta till nästa fall.
- Standardsatsen är valfri och kan visas var som helst i switchblocket. I fallet, om det inte är i slutet, måste en break-sats behållas efter standardsatsen för att utesluta exekveringen av nästa case-sats.
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.>
Flödesschema för Switch-Case Statement
Det här flödesschemat visar kontrollflödet och hur switchsatserna fungerar:
Notera: Java switch-sats är en fall-through-sats som betyder att den exekverar alla satser if bryt nyckelord används inte, så det är mycket viktigt att använda nyckelordet break i varje fall.
Exempel: Hitta dag
Tänk på följande Java-program, det deklarerar en int namngiven dag vars värde representerar en dag(1-7). Koden visar namnet på dagen, baserat på dagens värde, med hjälp av switch-satsen.
Java // 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); } }> Produktion
Friday>
brott i växellåda Uttalanden
A bryta uttalande är valfritt. Om vi utelämnar avbrottet kommer exekveringen att fortsätta till nästa fall.
Ibland är det önskvärt att ha flera fall utan ha sönder uttalanden dem emellan. Låt oss till exempel överväga den uppdaterade versionen av programmet ovan, det visar också om en dag är en vardag eller en helgdag.
Exempel:
Byt uttalandeprogram utan flera pauser
Java // 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); } }> Produktion
Tuesday is a Weekday>
Java Nested Switch-utlåtanden
Vi kan använda en växla som del av uttalandesekvensen av en yttre strömbrytare. Detta kallas a kapslad switch . Eftersom en switch-sats definierar sitt block, uppstår inga konflikter mellan fallkonstanterna i den inre switchen och de i den yttre switchen.
Exempel:
Uttalande av kapslad switch
Java // 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'); } } } }> Produktion
elective courses : Machine Learning, Big Data>
Java Enum i Switch Statement
Uppräkningar (uppräkningar) är ett kraftfullt och tydligt sätt att representerar en fast uppsättning namngivna konstanter i Java.
Enums används i Switch-satser på grund av deras typsäkerhet och läsbarhet.
Exempel:
Användning av Enum i Switch
Java // 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'); } } } }> Produktion
Sunday Monday Tuesday Wednesday Thursday Friday Saturday>
standardsats i Java Switch Case
standardfall i Switch-fallet anger vilken kod som ska köras om inget fall matchar.
Det är att föredra att skriva standardfallet i slutet av alla möjliga fall, men det kan skrivas var som helst i switch-satser.
Exempel:
Skriver standard i mitten av switch-satser:
Java /*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); } } }> Produktion
2 3>
Exempel:
Skriver standard vid start av switch-satser
Java 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); } } }> Produktion
Default 1>
Variationer av fodraletiketter
Caseetikett och växlingsargument kan vara ett konstant uttryck. Switchargumentet kan vara ett variabelt uttryck.
Exempel:
Använder variabla switchargument.
Java 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'); } } }> Produktion
3>
En case-etikett kan inte vara ett variabel- eller variabeluttryck. Det måste vara ett konstant uttryck.
Java 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-utlåtanden
Java ger fyra omslagsklasser att använda: Integer, Short, Byte och Long i switch-satser.
Exempel:
Java Wrapper i växellåda.
Java 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:
You are 25.>
Notera:
Oavsett dess placering exekveras standardfallet endast om inget av de andra ärendevillkoren är uppfyllda. Så att sätta det i början, mitten eller slutet ändrar inte kärnlogiken (såvida du inte använder en mindre vanlig teknik som kallas genomgång).
Exempel: I den här koden kommer vi att identifiera veckodagen genom (1-7) nummer.
Java 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 mer:
java oops koncept
- Användning av Enum och Switch Keyword i Java
- String i Switch Case i Java
- Java handledning
Träning
För att öva Java switch-satser kan du besöka sidan: Java Switch Case statement Practice
Slutsats
Switch-satser i Java är kontrollflödesstrukturer som låter dig exekvera ett visst kodblock baserat på värdet av ett enda uttryck. De kan betraktas som ett alternativ till if-else-if-satser i programmering.
Java Switch-uttalanden - Vanliga frågor
Hur man använder switch-satser i Java
För att använda switch-satsen i Java kan du använda följande syntax:
switch (uttryck) {
fall värde1:
// kod som ska köras om uttryck är lika med värde1
ha sönder;
fall värde2:
// kod som ska köras om uttryck är lika med värde2
ha sönder;
// … fler fall
standard:
// kod som ska köras om inget av ovanstående fall matchar
}
Kan vi skicka noll till en switch
Nej, du kan inte skicka NULL till en switch-sats eftersom de kräver konstant uttryck i dess fall.
Kan du återgå till en switch-sats
Nej, switch-satser bygger ett kontrollflöde i programmet, så det kan inte gå tillbaka efter att ha avslutat ett switchfall.