The príkaz switch v jazyku Java je viacsmerný príkaz vetvy. Jednoducho povedané, príkaz Java switch vykoná jeden príkaz z viacerých podmienok.

reťazec k itn

Je to ako keby-inak-ak rebríček vyhlásenie. Poskytuje jednoduchý spôsob odosielania vykonávania do rôznych častí kódu na základe hodnoty výrazu. Výraz môže byť a byte , krátky , char , alebo int primitívny dátový typ. Testuje rovnosť premenných voči viacerým hodnotám.

Poznámka: Výraz prepínača Java musí mať bajt, krátky, int, dlhý (s jeho typom Wrapper), enum a reťazec. Počnúc JDK7 funguje aj s vymenovanými typmi ( Enums v jave), Reťazec triedy a Zavinovačka triedy.

Syntax

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

Príklad:

Príklad veľkostnej tlačiarne

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

Výkon:

Small>

Niektoré dôležité pravidlá pre príkazy Java Switch

1. Môže existovať ľubovoľný počet prípadov, ktoré vyžadujú kontrolu stavu, ale nezabudnite, že duplicitné hodnoty prípadov nie sú povolené.
2. Hodnota pre prípad musí byť rovnakého typu údajov ako premenná v prepínači.
3. Hodnota prípadu musí byť konštantná alebo doslovná. Premenné nie sú povolené.
4. Príkaz break sa používa vo vnútri prepínača na ukončenie sekvencie príkazov.
5. Príkaz break je voliteľný. Ak sa vynechá, exekúcia bude pokračovať v ďalšom prípade.
6. Predvolený príkaz je voliteľný a môže sa objaviť kdekoľvek v bloku prepínačov. V prípade, ak nie je na konci, potom sa musí po predvolenom príkaze ponechať príkaz break, aby sa vynechalo vykonanie ďalšieho príkazu 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.>

Vývojový diagram vyhlásenia o prepínači

Tento vývojový diagram ukazuje tok riadenia a fungovanie príkazov switch:

Poznámka: Java switch príkaz je pádový príkaz, čo znamená, že vykoná všetky príkazy if kľúčové slovo zlomiť sa nepoužíva, takže je veľmi dôležité použiť kľúčové slovo break v každom prípade.

Príklad: Deň hľadania

Zoberme si nasledujúci Java program, ktorý deklaruje int pomenovaný deň, ktorého hodnota predstavuje deň (1-7). Kód zobrazuje názov dňa na základe hodnoty dňa pomocou príkazu 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>

prestávka v skrinke spínača

A vyhlásenie o prerušení je voliteľná. Ak prestávku vynecháme, exekúcia bude pokračovať v ďalšom prípade.

Niekedy je žiaduce mať viacero prípadov bez prestávka vyhlásenia medzi nimi. Zoberme si napríklad aktualizovanú verziu vyššie uvedeného programu, ktorá tiež zobrazuje, či je deň pracovný deň alebo víkend.

jvm v jazyku Java

Príklad:

Prepnite program príkazov bez viacerých prestávok

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

Môžeme použiť a prepínač ako časť sekvencie príkazov z an vonkajší spínač. Toto sa nazýva a vnorený prepínač . Keďže príkaz switch definuje svoj blok, nevznikajú žiadne konflikty medzi konštantami veľkých písmen vo vnútornom prepínači a konštantami vo vonkajšom prepínači.

Príklad:

Nested Switch Statement

// 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 v príkaze Switch

Enumerácie (enumy) sú silným a jasným spôsobom predstavujú pevnú množinu pomenovaných konštánt v Jave.

Enumy sa používajú v príkazoch Switch kvôli ich typovej bezpečnosti a čitateľnosti.

Príklad:

Použitie Enum v 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>

predvolený príkaz v prípade Java Switch Case

predvolený prípad v prípade prepínača určuje, aký kód sa má spustiť, ak sa nezhoduje žiadny prípad.

Uprednostňuje sa napísať predvolený prípad na koniec všetkých možných prípadov, ale možno ho zapísať na ľubovoľné miesto v príkazoch switch.

Príklad:

Zápis predvoleného nastavenia uprostred príkazov 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>

Príklad:

Predvolený zápis pri spúšťaní príkazov switch

ako zatvoriť režim vývojára

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>

Variácie štítkov na puzdre

Argumenty označenia veľkých písmen a prepínača môžu byť konštantným výrazom. Argumentom switch môže byť premenný výraz.

Príklad:

Použitie argumentu premenného prepínača.

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>

Označenie prípadu nemôže byť premenná alebo variabilný výraz. Musí to byť konštantný prejav.

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 v príkazoch Switch

Java poskytuje štyri obalové triedy použiť: Integer, Short, Byte a Long v príkazoch switch.

Príklad:

Java Wrapper v puzdre spínača.

.ďalšia 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.');  }  } }>

Výkon:

You are 25.>

Poznámka:

Bez ohľadu na jeho umiestnenie sa predvolený prípad vykoná len vtedy, ak nie je splnená žiadna z ostatných podmienok prípadu. Takže jeho umiestnenie na začiatok, stred alebo koniec nemení základnú logiku (pokiaľ nepoužívate menej bežnú techniku ​​nazývanú prepadnutie).

Príklad: V tomto kóde identifikujeme deň v týždni pomocou (1-7) čísel.

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

Výkon

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

Čítaj viac:

• Použitie kľúčových slov Enum a Switch v jazyku Java
• Reťazec v puzdre Switch v jazyku Java
• Výukový program Java

Cvičenie

Na precvičenie príkazov Java Switch môžete navštíviť stránku: Java Switch Case statement Practice

Záver

Príkazy Switch v jazyku Java sú štruktúry riadiaceho toku, ktoré vám umožňujú vykonať určitý blok kódu na základe hodnoty jedného výrazu. Možno ich považovať za alternatívu k príkazom if-else-if v programovaní.

skryté aplikácie

Vyhlásenia o prepínači Java - často kladené otázky

Ako používať príkazy switch v jazyku Java

Ak chcete použiť príkaz switch v jazyku Java, môžete použiť nasledujúcu syntax:

prepínač (výraz) {
hodnota prípadu 1:
// kód, ktorý sa má vykonať, ak sa výraz rovná hodnote1
prestávka;
case value2:
// kód, ktorý sa má vykonať, ak sa výraz rovná hodnote2
prestávka;
// ... viac prípadov
predvolene:
// kód, ktorý sa má spustiť, ak sa nezhoduje žiadny z vyššie uvedených prípadov
}

Môžeme prejsť null na prepínač

Nie, do príkazu switch nemôžete zadať hodnotu NULL, pretože vyžadujú konštantný výraz.

Môžete sa vrátiť k príkazu switch

Nie, príkazy switch vytvárajú v programe riadiaci tok, takže sa po opustení prípadu prepínača nemôže vrátiť späť.