The příkaz switch v Javě je vícesměrný příkaz větve. Jednoduše řečeno, příkaz Java switch provede jeden příkaz z více podmínek.
Je to jako kdyby-jinak-kdyby žebříček prohlášení. Poskytuje snadný způsob, jak odeslat provádění do různých částí kódu na základě hodnoty výrazu. Výraz může být a byte , krátký , char nebo int primitivní datový typ. Testuje rovnost proměnných proti více hodnotám.
Poznámka: Výraz přepínače Java musí mít bajt, krátký, int, dlouhý (s jeho typem Wrapper), výčty a řetězec. Počínaje JDK7 pracuje také s vyjmenovanými typy ( Výčty v Javě), Tětiva třídy a Obal třídy.
Syntax
switch(expression) { case value1 : // Statements break; // break is optional case value2 : // Statements break; // break is optional .... .... .... default : // default Statement }>Příklad:
Příklad velikosti tiskárny
Jáva 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ýstup:
Small>
Některá důležitá pravidla pro příkazy Java Switch
- Může existovat libovolný počet případů, které vyžadují pouze kontrolu stavu, ale nezapomeňte, že duplicitní hodnoty případů nejsou povoleny.
- Hodnota pro případ musí být stejného datového typu jako proměnná v přepínači.
- Hodnota pro případ musí být konstantní nebo doslovná. Proměnné nejsou povoleny.
- Příkaz break se používá uvnitř přepínače k ukončení sekvence příkazů.
- Příkaz break je volitelný. Pokud je vynechán, bude provádění pokračovat do dalšího případu.
- Výchozí příkaz je volitelný a může se objevit kdekoli uvnitř bloku přepínače. V případě, že není na konci, musí být po výchozím příkazu zachován příkaz break, aby se vynechalo provedení dalšího pří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 prohlášení Switch-Case
Tento vývojový diagram ukazuje tok řízení a fungování příkazů přepínače:
Poznámka: Příkaz Java switch je pádový příkaz, což znamená, že provede všechny příkazy if klíčové slovo break se nepoužívá, takže je velmi důležité v každém případě použít klíčové slovo break.
seznam java array
Příklad: Den hledání
Vezměme si následující Java program, deklaruje int pojmenovaný den, jehož hodnota představuje den (1-7). Kód zobrazí název dne na základě hodnoty dne pomocí příkazu switch.
Jáva // 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); } }> Výstup
Friday>
break in switch case Příkazy
A příkaz break je volitelný. Pokud vynecháme přestávku, bude exekuce pokračovat do dalšího případu.
Někdy je žádoucí mít více případů bez přestávka prohlášení mezi nimi. Vezměme si například aktualizovanou verzi výše uvedeného programu, která také zobrazuje, zda je den všední nebo víkendový.
Příklad:
Přepnout příkazový program bez více přestávek
Jáva // 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); } }> Výstup
Tuesday is a Weekday>
Příkazy Java Nested Switch
Můžeme použít a přepínač tak jako část sekvence příkazů z an vnější spínač. Toto se nazývá a vnořený přepínač . Protože příkaz switch definuje svůj blok, nevznikají žádné konflikty mezi konstantami velkých písmen ve vnitřním přepínači a konstantami ve vnějším přepínači.
Příklad:
Vnořený příkaz Switch
Jáva // 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'); } } } }> Výstup
elective courses : Machine Learning, Big Data>
Java Enum v příkazu Switch
Enumerace (výčty) jsou mocným a jasným způsobem představují pevnou množinu pojmenovaných konstant v Javě.
Výčty se používají v příkazech Switch kvůli jejich typové bezpečnosti a čitelnosti.
Příklad:
Použití Enum ve Switch
Jáva // 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'); } } } }> Výstup
Sunday Monday Tuesday Wednesday Thursday Friday Saturday>
výchozí příkaz v Java Switch Case
výchozí případ v případě přepínače určuje, jaký kód se má spustit, pokud neodpovídá žádný případ.
Upřednostňuje se napsat výchozí případ na konec všech možných případů, ale lze jej zapsat na libovolné místo v příkazech switch.
Příklad:
Zápis výchozího nastavení uprostřed příkazů přepínače:
Jáva /*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); } } }> Výstup
2 3>
Příklad:
Zápis výchozího nastavení při spouštění příkazů switch
Jáva 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); } } }> Výstup
Default 1>
Variace štítků pouzdra
Argumenty označení případu a přepínače mohou být konstantním výrazem. Argument přepínače může být proměnný výraz.
Příklad:
Použití argumentu proměnného přepínače.
Jáva 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'); } } }> Výstup
3>
Označení případu nemůže být proměnná nebo variabilní výraz. Musí to být konstantní výraz.
Jáva 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 příkazech přepínače
Java nabízí čtyři obalové třídy použít: Integer, Short, Byte a Long v příkazech switch.
Příklad:
Java Wrapper v pouzdru přepínače.
Jáva 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ýstup:
You are 25.>
Poznámka:
Bez ohledu na jeho umístění se výchozí případ provede pouze v případě, že není splněna žádná z ostatních podmínek případu. Umístění na začátek, střed nebo konec tedy nezmění základní logiku (pokud nepoužíváte méně běžnou techniku zvanou propadnutí).
Příklad: V tomto kódu identifikujeme den v týdnu pomocí (1-7) čísel.
Jáva 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ýstup
Enter a day number (1-7): 8 Not a valid weekday.>
Přečtěte si více:
- Použití klíčových slov Enum a Switch v Javě
- Řetězec v pouzdru Switch Case v Javě
- Výukový program Java
Cvičení
Pro procvičení příkazů Java switch můžete navštívit stránku: Java Switch Case statement Practice
Závěr
Příkazy Switch v Javě jsou struktury řídicího toku, které vám umožňují provádět určitý blok kódu na základě hodnoty jednoho výrazu. Mohou být považovány za alternativu k příkazům if-else-if v programování.
Vyjádření Java Switch - FAQ
Jak používat příkazy switch v Javě
Chcete-li použít příkaz switch v Javě, můžete použít následující syntaxi:
přepínač (výraz) {
case value1:
// kód, který se má provést, pokud se výraz rovná hodnotě1
přestávka;
case value2:
// kód, který se má provést, pokud se výraz rovná hodnotě2
přestávka;
// … více případů
výchozí:
// kód, který se má spustit, pokud žádný z výše uvedených případů neodpovídá
}
Můžeme předat null přepínači
Ne, do příkazu switch nemůžete předat NULL, protože vyžadují konstantní výraz v jeho případě.
Můžete se vrátit k příkazu switch
Ne, příkazy switch vytvářejí řídicí tok v programu, takže se po ukončení případu přepínače nemůže vrátit zpět.