Menu

Prohlášení o případu Java Switch s příklady programování

  • Hlavní
  • Jiný
  • Prohlášení o případu Java Switch s příklady programování

java switch case statement with programming examples

Vyzkoušejte Náš Nástroj Pro Odstranění Problémů

Naučte se o Java Switch Statement, Nested Switch, dalších variantách a použití pomocí jednoduchých příkladů:

V tomto tutoriálu probereme příkaz Java Switch. Zde prozkoumáme každý koncept související s příkazem Switch spolu s příklady programování a jejich popisem.

Dostanete dostatek příkladů, které vám umožní lépe pochopit dané téma a umožní vám také vytvářet programy, kdykoli budete muset použít příkaz Přepnout.

Některé z často kladených otázek jsou zahrnuty, abyste si byli vědomi trendových otázek, které jsou kladeny v souvislosti s příkazem Přepnout.

=> Prohlédněte si příručku Java Beginners Guide zde.

Prohlášení Java Switch (1)

Co se naučíte:

jaký je nejlepší youtube video převodník

Prohlášení Java Switch

V tomto kurzu se budeme zabývat následujícími variacemi příkazu Java Switch.

  • Přepnout prohlášení
  • Prohlášení o vnořeném přepínači (vnitřní a vnější přepínač)

Příkaz Switch v Javě je příkaz větve nebo příkaz rozhodování, který poskytuje způsob, jak spustit váš kód v různých případech nebo částech, které jsou založeny na hodnotě výrazu nebo podmínky. Častěji je to příkaz Java Switch, který poskytuje lepší alternativu než různé možnosti dostupné v příkazech Java if-else.

Syntax:

switch (expression){ case 1: //statement of case 1 break; case 2: //statement of case 2 break; case 3: //statement of case 3 break; . . . case N: //statement of case N break; default; //default statement }

Prohlášení Java Switch

Pravidla pro prohlášení o změně

Níže jsou uvedena důležitá pravidla pro příkaz Switch.

  • Duplicitní případy nebo hodnoty případu nejsou povoleny.
  • Hodnota případu Switch by měla být stejného datového typu jako proměnná Switch case. Pro Např. - pokud je „x“ celočíselného typu v „switch (x)“, pak by všechny případy Switch měly být celočíselného typu.
  • The Příkazy Java break lze použít (volitelně) k ukončení posloupnosti spustitelných souborů uvnitř pouzdra.
  • Výchozí příkaz je také volitelný. Obvykle je přítomen na konci příkazu Switch. Výchozí příkaz se provede, pokud žádný z případů Switch neodpovídá hodnotě proměnné Switch.
  • Hodnota případu Switch musí být konstantní, nikoli proměnná.

Pouzdro přepněte pomocí smyčky

Níže je uveden ukázkový program, kde jsme demonstrovali, jak příkaz Java Switch funguje nebo může být použit v programech. Nejprve jsme inicializovali hodnotu ‚i 'uvnitř pro smyčku a zadali podmínku.

Poté jsme implementovali příkaz Switch se dvěma případy a jedním výchozím nastavením. Výchozí příkaz bude pokračovat v provádění, dokud „i<5”. In this case, it will execute 2 times for “i=3” and “i=4”.

public class example { public static void main(String() args) { /* * Switch statement starts here. Added three cases and * one default statement. The default statement will * keep on executing until i<5. In this case, it will * execute 2 times for i=3 and i=4. */ for(int i=0; i<5; i++) { switch(i){ case 0: System.out.println('i value is 0'); break; case 1: System.out.println('i value is 1'); break; case 2: System.out.println('i value is 2'); break; default: System.out.println('i value is greater than 2 and less than 5'); } } } }

Výstup:

Pouzdro spínače pomocí smyčkového výstupu

Přestávka je nepovinná

V případě přepínače Java je příkaz break volitelný. I když přestávku odstraníte, ovládání programu bude plynout k dalšímu případu.

Uvažujme následující příklad.

public class example { public static void main(String() args) { /* * Switch statement starts here. Added 10 cases and * one default statement. Execution will flow through * each of these cases case 0 to case 4 and case 5 to * case 9 until it finds a break statement. */ for(int i=0; i<=10; i++) { switch(i){ case 0: case 1: case 2: case 3: case 4: System.out.println('i value is less than 5'); break; case 5: case 6: case 7: case 8: case 9: System.out.println('i value is less than 10'); break; default: System.out.println('Default statement'); } } } }

Výstup

Přerušení je volitelné - výstup

Vnořený přepínač

To zahrnuje koncept vnitřního a vnějšího přepínače. Můžeme použít vnitřní přepínač jako součást příkazu vnějšího přepínače. Tento typ příkazu Switch se nazývá příkaz Nested Switch nebo Switch (Inner) inside a Switch (Outer) is known as a Nested Switch.

Syntax:

switch (count){ case 1: switch (target){ //nested switch statement case 0: System.out.println(“target is 0”); break; case 1: System.out.println(“target is 1”); break; } break; case 2: //… }

Hledání „a“ a „b“ pomocí vnořeného přepínače

V níže uvedeném příkladu jsme použili třídu skeneru k zadání „a“ a „b“ prostřednictvím konzoly. Poté jsme použili vnitřní a vnější přepínač k určení různých případů pro hodnotu „a“ a „b“.

Ovládací prvek bude procházet těmito vnitřními a vnějšími příkazy Switch, a pokud se zadaná hodnota shoduje, pak tuto hodnotu vytiskne. Jinak se vytiskne výchozí výpis.

import java.util.Scanner; public class example { public static void main(String() args) { int a,b; System.out.println('Enter a and b'); Scanner in = new Scanner(System.in); a = in.nextInt(); b = in.nextInt(); // Outer Switch starts here switch (a) { // If a = 1 case 1: // Inner Switch starts here switch (b) { // for condition b = 1 case 1: System.out.println('b is 1'); break; // for condition b = 2 case 2: System.out.println('b is 2'); break; // for condition b = 3 case 3: System.out.println('b is 3'); break; } break; // for condition a = 2 case 2: System.out.println('a is 2'); break; // for condition a == 3 case 3: System.out.println('a is 3'); break; default: System.out.println('default statement here'); break; } } }

Výstup

Hledání a a b pomocí vnořeného přepínače

Přepnout příkaz pomocí řetězce

V JDK 7.0 a novějších jsme oprávněni používat String objekty ve výrazu Switch nebo podmínce.

Níže je uveden příklad, kde jsme v příkazu Switch použili řetězec. Můžeme použít řetězce v příkazu Switch stejně jako celá čísla.

import java.util.Scanner; public class example { public static void main(String() args) { String mobile = 'iPhone'; switch (mobile) { case 'samsung': System.out.println('Buy a Samsung phone'); break; case 'iPhone': System.out.println('Buy an iPhone'); break; case 'Motorola': System.out.println('Buy a Motorola phone'); } } }

Výstup

Přepnout příkaz pomocí řetězce

Obálka v prohlášení přepínače

JDK 7.0 a novější, příkaz Switch pracuje také s třídou Wrapper. Zde ukážeme Java Wrapper v příkazu Switch.

V níže uvedeném příkladu jsme použili třídu Integer, která zabalí hodnotu primitivního typu int do objektu. Pomocí této třídy jsme inicializovali Wrapperovou proměnnou „x“ s hodnotou 3.

Pomocí proměnné Wrapper (uvnitř příkazu Switch) jsme definovali tři různé případy spolu s jedním výchozím případem. Podle toho, který případ se shoduje s hodnotou „x“, bude tento konkrétní případ proveden.

public class example { public static void main(String() args) { // Initializing a Wrapper variable Integer x = 3; // Switch statement with Wrapper variable x switch (x) { case 1: System.out.println('Value of x = 1'); break; case 2: System.out.println('Value of x = 2'); break; case 3: System.out.println('Value of x = 3'); break; // Default case statement default: System.out.println('Value of x is undefined'); } } }

Výstup

Obálka v příkazu Switch

Java Enum v prohlášení přepínače

V JDK 7.0 a novějších funguje příkaz Switch dobře s výčtem Java. V této části si ukážeme výčet Java v příkazu switch.

Zde jsme vytvořili výčet s názvem boty se čtyřmi konstantami, které jsou v zásadě značkami obuvi. Poté jsme enumerátor uložili do referenční proměnné a1.

Pomocí této referenční proměnné a1 jsme inicializovali příkaz Switch se čtyřmi různými případy. Bez ohledu na případ, který odpovídá hodnotě referenční proměnné, bude daný případ proveden.

/* * created an enumeration called shoes * with four enumerators. */ enum shoes { Nike, Adidas, Puma, Reebok; } public class example { public static void main(String() args) { /* * stored enumerator in reference variable a1 for constant = Adidas */ shoes a1 = shoes.Adidas; /* * Started Switch Statement and if the element matches with a1 then it * will print the statement specified in the case */ switch (a1) { // does not match case Nike: System.out.println('Nike - Just do it'); break; // matches case Adidas: System.out.println('Adidas - Impossible is nothing'); break; // does not match case Puma: System.out.println('Puma - Forever Faster'); break; // does not match case Reebok: System.out.println('Reebok - I Am What I Am'); break; } } }

Výstup

Výčet Java v příkazu switch

Často kladené otázky

Otázka č. 1) Co je to příkaz Java Switch?

Odpovědět: Příkaz Switch v Javě je příkaz větve nebo příkaz rozhodování (stejně jako příkaz Java if-else), který poskytuje způsob, jak spustit kód v různých případech. Tyto případy jsou založeny na nějakém výrazu nebo podmínce.

Příkaz Java Switch se většinou osvědčil jako lepší alternativa pro rozhodování než příkaz Java if-else.

Otázka č. 2) Jak napíšete příkaz Switch v Javě?

Odpovědět: Níže je uveden ukázkový program, kde jsme použili příkaz Switch. Zde jsme vzali celé číslo s názvem značka s hodnotou 4 a poté jsme toto celé číslo použili v příkazu Switch pro různé případy.

Celočíselná hodnota značky odpovídá případu a poté se vytiskne výpis konkrétního případu.

import java.util.Scanner; public class example { public static void main(String() args) { int brand = 4; String name; // Switch statement starts here switch(brand){ case 1: name = 'Nike'; break; case 2: name = 'Dolce & Gabbana'; break; case 3: name = 'Prada'; break; case 4: name = 'Louis Vuitton'; break; default: name = 'Invalid name'; break; } System.out.println('The brand name is: ' + name); } }

Výstup

Přepnout prohlášení v Javě

Otázka č. 3) Uveďte příklad příkazu Switch.

Odpovědět: V tomto kurzu je spousta příkladů příkazu Switch. Uvedli jsme všechny možné příklady, ať už jde o přepínač s celým číslem nebo přepínač s řetězcem.

Můžete odkázat na příklady uvedené na začátku tohoto kurzu, abyste si byli vědomi základů příkazu Switch a jak se používá se smyčkami. (Viz část „Pouzdro přepínače pro smyčku“)

Otázka č. 4) Potřebujete v příkazu switch výchozí případ?

Odpovědět: Ne, není povinné používat výchozí případ při práci s příkazem Switch.

Například pokud vidíte níže uvedený příklad, kde jsme nepoužili výchozí případ. I když nepoužíváme výchozí případ, program se provede perfektně, pokud najde odpovídající případ.

import java.util.Scanner; public class example { public static void main(String() args) { String author = 'Saket'; switch (author) { case 'John': System.out.println('John is the author'); break; case 'Michael': System.out.println('Michael is the author'); break; case 'Rebecca': System.out.println('Rebecca is the author'); break; case 'Saket': System.out.println('Saket is the author'); break; case 'Steve': System.out.println('Steve is the author'); break; } } }

Výstup

Přepínač - příklad

Závěr

V tomto kurzu jsme diskutovali o příkazu Java Switch spolu se syntaxí, popisem a vývojovým diagramem. Jedna další variace, kterou je příkaz Vnořený přepínač, je také podrobně popsána pomocí vhodných příkladů, včetně konceptu vnitřního a vnějšího přepínače.

Zde jsou také uvedeny některé často kladené otázky, abyste měli přehled o trendových otázkách souvisejících s příkazem Java Switch. Tyto rozhodovací výroky budou užitečné, když chcete oddělit kód na základě nějaké podmínky nebo výrazu a chcete zkontrolovat více případů.

=> Zkontrolujte VŠECHNY výukové programy Java zde.

Doporučené čtení

^