De switch-instructie in Java is een multi-way branch-instructie. In eenvoudige bewoordingen voert de Java-switch-instructie één instructie uit op basis van meerdere voorwaarden.

Het is als een als-anders-als ladder verklaring. Het biedt een eenvoudige manier om de uitvoering naar verschillende delen van de code te verzenden op basis van de waarde van de expressie. De uitdrukking kan a zijn byte , kort , verkoold , of int primitief gegevenstype. Het test de gelijkheid van variabelen aan de hand van meerdere waarden.

Opmerking: De Java-switchexpressie moet bestaan ​​uit byte, short, int, long (met het Wrapper-type), enums en string. Vanaf JDK7 werkt het ook met opgesomde typen ( Enums in Java), de Snaar klasse, en Wikkel klassen.

Syntaxis

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

Voorbeeld:

Formaat printervoorbeeld

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

Uitgang:

Small>

Enkele belangrijke regels voor Java Switch-instructies

1. Er kan een onbeperkt aantal gevallen zijn waarbij slechts een voorwaardecontrole wordt opgelegd, maar onthoud dat dubbele case(s)-waarden niet zijn toegestaan.
2. De waarde voor een case moet van hetzelfde gegevenstype zijn als de variabele in de switch.
3. De waarde voor een case moet constant of letterlijk zijn. Variabelen zijn niet toegestaan.
4. De break-instructie wordt binnen de switch gebruikt om een ​​instructiereeks te beëindigen.
5. De break-instructie is optioneel. Als dit wordt weggelaten, gaat de uitvoering door naar de volgende zaak.
6. De standaardinstructie is optioneel en kan overal in het schakelblok verschijnen. Als dit niet aan het einde is, moet een break-instructie na de standaardinstructie worden bewaard om de uitvoering van de volgende case-instructie over te slaan.

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

Stroomdiagram van Switch-Case-verklaring

Dit stroomdiagram toont de besturingsstroom en werking van switch-instructies:

Opmerking: De Java-switch-instructie is een fall-through-instructie, wat betekent dat alle instructies if worden uitgevoerd sleutelwoord breken wordt niet gebruikt, dus het is zeer essentieel om in elk geval het zoekwoord break te gebruiken.

Voorbeeld: Dag vinden

Beschouw het volgende Java-programma: het declareert een int met de naam dag waarvan de waarde een dag (1-7) vertegenwoordigt. De code geeft de naam van de dag weer, gebaseerd op de waarde van de dag, met behulp van de switch-instructie.

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

breuk in schakelkast Verklaringen

A verklaring breken is optioneel. Als we de pauze achterwege laten, gaat de uitvoering door in de volgende zaak.

Soms is het wenselijk om meerdere cases zonder te hebben pauze verklaringen daartussen. Laten we bijvoorbeeld eens kijken naar de bijgewerkte versie van het bovenstaande programma, deze geeft ook aan of een dag een weekdag of een weekenddag is.

Voorbeeld:

Schakel instructieprogramma uit zonder meerdere pauzes

// 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 Geneste Switch-instructies

Wij kunnen gebruik maken van een schakelaar als onderdeel van de instructiereeks van een buitenste schakelaar. Dit heet een geneste schakelaar . Omdat een switch-instructie zijn blok definieert, ontstaan ​​er geen conflicten tussen de hoofdletterconstanten in de binnenste schakelaar en die in de buitenste schakelaar.

Voorbeeld:

Geneste Switch-verklaring

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

Opsommingen (enums) zijn een krachtige en duidelijke manier om vertegenwoordigen een vaste reeks benoemde constanten op Java.

Enums worden gebruikt in Switch-instructies vanwege hun typeveiligheid en leesbaarheid.

Voorbeeld:

Gebruik van 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>

standaardinstructie in Java Switch Case

standaard case in de Switch-case specificeert welke code moet worden uitgevoerd als er geen case overeenkomt.

Het verdient de voorkeur om de standaard case aan het einde van alle mogelijke cases te schrijven, maar deze kan op elke plaats in switch-instructies worden geschreven.

Voorbeeld:

Standaard in het midden van switch-instructies schrijven:

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

Voorbeeld:

Standaard schrijven bij het starten van switch-instructies

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>

Variaties op dooslabels

Caselabel en switch-argumenten kunnen een constante expressie zijn. Het switch-argument kan een variabele expressie zijn.

Voorbeeld:

Met behulp van variabele-schakelaarargumenten.

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>

Een caselabel kan geen variabele of variabele-expressie zijn. Het moet een constante uitdrukking zijn.

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

Java biedt er vier wrap klassen te gebruiken: Integer, Short, Byte en Long in switch-instructies.

Voorbeeld:

Java-wrapper in schakelkast.

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

Uitgang:

You are 25.>

Opmerking:

Ongeacht de plaatsing wordt de standaardzaak alleen uitgevoerd als aan geen van de andere zaakvoorwaarden is voldaan. Dus als je het aan het begin, midden of einde plaatst, verandert de kernlogica niet (tenzij je een minder gebruikelijke techniek gebruikt die fall-through wordt genoemd).

Voorbeeld: In deze code identificeren we de weekdag via (1-7) cijfers.

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

Uitvoer

java boolean naar string

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

Lees verder:

• Gebruik van Enum en Switch Keyword in Java
• Tekenreeks in schakelkast in Java
• Java-zelfstudie

Oefening

Om Java-switch-instructies te oefenen, kunt u de pagina bezoeken: Java Switch Case-instructie Oefenen

Conclusie

Switch-instructies in Java zijn controlestroomstructuren waarmee u een bepaald codeblok kunt uitvoeren op basis van de waarde van een enkele expressie. Ze kunnen worden beschouwd als een alternatief voor if-else-if-instructies bij het programmeren.

Java Switch-verklaringen - Veelgestelde vragen

Hoe switch-instructies in Java te gebruiken

Om de switch-instructie in Java te gebruiken, kunt u de volgende syntaxis gebruiken:

schakelaar (expressie) {
casuswaarde1:
// code die moet worden uitgevoerd als de expressie gelijk is aan waarde1
pauze;
casuswaarde2:
// code die moet worden uitgevoerd als de expressie gelijk is aan waarde2
pauze;
// … meer gevallen
standaard:
// code die moet worden uitgevoerd als geen van de bovenstaande gevallen overeenkomt
}

Kunnen we null doorgeven aan een schakelaar?

Nee, u kunt geen NULL doorgeven aan een switch-instructie, omdat deze in dat geval een constante expressie vereist.

Kunt u terugkeren naar een overstapverklaring?

Nee, switch-instructies bouwen een controlestroom in het programma op, zodat deze niet terug kan gaan na het verlaten van een switch-case.