Ce este o casă de comutare în Java și cum se utilizează?

Cazul comutator în Java este una dintre numeroasele instrucțiuni Java care spun limbajului de programare ce trebuie să facă. La fel ca propozițiile în limba engleză care oferă o idee completă a textului și includ clauze, instrucțiunile Java sunt comenzi care includ una sau mai multe expresii pe care le execută interpretul Java. În termeni mai simpli, o instrucțiune Java este o instrucțiune care explică ce ar trebui să se întâmple.

O instrucțiune Java se termină cu punct și virgulă (;) și îi spune lui Java să proceseze instrucțiuni până la acel punct și virgulă. În mod implicit, interpretul Java urmează ordinea în care sunt scrise instrucțiunile și rulează o instrucțiune după alta. Cu toate acestea, instrucțiunile care controlează fluxul programului (instrucțiuni de control al fluxului), cum ar fi bucle și condiționale, nu urmează ordinea implicită de execuție. Acest articol se concentrează pe un astfel de mecanism de control al selecției – declarația Java switch case.

Ce este un caz de comutare în Java?

Java acceptă trei tipuri de instrucțiuni: instrucțiuni de expresie pentru modificarea valorilor variabilelor, metode de apelare și crearea de obiecte, instrucțiuni de declarare pentru declararea variabilelor și instrucțiuni de flux de control pentru determinarea ordinii de execuție a instrucțiunilor.

Instrucțiunea Java switch case este un tip de instrucțiune control-flow care permite valorii unei expresii sau variabilei să modifice fluxul de control al execuției programului printr-o ramură multidirecțională. Spre deosebire de instrucțiunile if-then și if-then-else, instrucțiunea Java switch are mai multe căi de execuție. Switch case în Java funcționează cu tipuri de date primitive short, byte, int și char. Din JDK7, comutatorul Java poate fi folosit și cu clasa String, tipuri enumerate și clase Wrapper care încapsulează tipuri de date primitive, cum ar fi Byte, Character, Integer și Short.

Corpul unei instrucțiuni switch case în Java se numește bloc switch. Fiecare instrucțiune din blocul de comutare este etichetată folosind unul sau mai multe cazuri sau etichete implicite. Prin urmare, instrucțiunea switch își evaluează expresia, urmată de execuția tuturor instrucțiunilor care urmează eticheta casei potrivite.

Mai jos este prezentată sintaxa instrucțiunii switch case:

// instrucțiunea de comutare

comuta (expresie)

{

// declarații de caz

// valorile trebuie să fie de același tip de expresie

valoare caz 1:

// Declarații

pauză; // break este opțional

valoare caz 2:

// Declarații

pauză; // break este opțional

// Putem avea orice număr de declarații de caz

// de mai jos este declarația implicită, folosită atunci când niciunul dintre cazuri nu este adevărat.

// Nu este necesară nicio pauză în cazul implicit.

Mod implicit :

// Declarații

}

Exemplu de instrucțiune Java switch

Următorul exemplu de cod Java declară un int numit „lună” a cărui valoare reprezintă una dintre cele 12 luni ale anului. Codul folosește declarația switch case pentru a afișa numele lunii pe baza valorii lunii.

clasă publică SwitchExample {

public static void main(String[] args) {

int luna = 6;

String monthString;

comutare (lună) {

cazul 1: monthString = „Ianuarie”;

pauză;

cazul 2: monthString = „februarie”;

pauză;

cazul 3: monthString = „March”;

pauză;

cazul 4: monthString = „aprilie”;

pauză;

cazul 5: monthString = „May”;

pauză;

cazul 6: monthString = „Iunie”;

pauză;

cazul 7: monthString = „iulie”;

pauză;

cazul 8: monthString = „August”;

pauză;

cazul 9: monthString = „septembrie”;

pauză;

cazul 10: monthString = „Octombrie”;

pauză;

cazul 11: monthString = „noiembrie”;

pauză;

cazul 12: monthString = „decembrie”;

pauză;

implicit: monthString = „Lună nevalidă”;

pauză;

}

System.out.println(monthString);

}

}

Ieșire: iunie

Scopul declarației break în cazul comutatorului Java

Instrucțiunea break este un aspect esențial al cazului de comutare Java care termină instrucțiunea switch inclusă. Instrucțiunea break este necesară, deoarece fără ea, instrucțiunile din blocul switch ar cădea. Astfel, indiferent de expresia etichetelor de caz ulterioare, toate instrucțiunile de după eticheta de caz care se potrivesc sunt executate secvențial până când este întâlnită o instrucțiune break.

Următorul cod este un exemplu pentru a arăta un bloc comutator care se încadrează în absența instrucțiunii break.

clasă publică SwitchExampleFallThrough {

public static void main(String[] args) {

java.util.ArrayList<String> futureMonths =

nou java.util.ArrayList<String>();

int luna = 6;

comutare (lună) {

cazul 1: futureMonths.add(„Ianuarie”);

cazul 2: futureMonths.add(„februarie”);

cazul 3: futureMonths.add(„Martie”);

cazul 4: futureMonths.add(„aprilie”);

cazul 5: futureMonths.add(„Mai”);

cazul 6: futureMonths.add(„Iunie”);

cazul 7: futureMonths.add(„iulie”);

cazul 8: futureMonths.add(„August”);

cazul 9: futureMonths.add(„Septembrie”);

cazul 10: futureMonths.add(„Octombrie”);

cazul 11: futureMonths.add(„noiembrie”);

cazul 12: futureMonths.add(„Decembrie”);

pauză;

implicit: break;

}

if (futureMonths.isEmpty()) {

System.out.println(„Număr lunar nevalid”);

} altfel {

pentru (String monthName: futureMonths) {

System.out.println(monthName);

}

}

}

}

Ieșire:

iunie

iulie

August

Septembrie

octombrie

noiembrie

decembrie

Codul de mai sus afișează luna anului corespunzătoare lunii întregi și lunile care urmează. Aici, instrucțiunea final break nu servește la nimic, deoarece fluxul iese din instrucțiunea switch. Utilizarea instrucțiunii break este utilă deoarece face codul mai puțin predispus la erori și modificările mai ușoare. Secțiunea implicită din cod gestionează toate valorile care nu sunt reglementate de niciuna dintre secțiunile de caz.

Declarație de comutare Java cu mai multe etichete de majuscule

Instrucțiunile Switch în Java pot avea, de asemenea, mai multe etichete de caz. Următorul cod ilustrează același lucru – aici se calculează numărul de zile dintr-o anumită lună a anului.

clasa SwitchMultiple{

public static void main(String[] args) {

int luna = 2;

int an = 2020;

int numDays = 0;

comutare (lună) {

cazul 1: cazul 3: cazul 5:

cazul 7: cazul 8: cazul 10:

cazul 12:

numZile = 31;

pauză;

cazul 4: cazul 6:

cazul 9: cazul 11:

numZile = 30;

pauză;

cazul 2:

dacă (((an % 4 == 0) &&

!(an % 100 == 0))

|| (an % 400 == 0))

numZile = 29;

altfel

numZile = 28;

pauză;

Mod implicit:

System.out.println(„Lună invalidă.”);

pauză;

}

System.out.println(„Număr de zile = „

+ numZile);

}

}

Ieșire:

Număr de zile = 29

Instrucțiuni de caz de comutare Java imbricate

Un comutator imbricat este atunci când utilizați un comutator ca parte a secvenței de instrucțiuni a unui comutator exterior. În acest caz, nu există nici un conflict între constantele case din celălalt comutator și cele din comutatorul intern, deoarece o instrucțiune switch își definește propriul bloc.

Următorul exemplu demonstrează utilizarea instrucțiunilor switch-case Java imbricate :

clasă publică TestNest {

public static void main(String[] args)

{

Ramura șir = „CSE”;

int an = 2;

comutator (an) {

cazul 1:

System.out.println(„Cursuri opționale: Algebră, Engleză avansată”);

pauză;

cazul 2:

comutator (Ramură) // comutator imbricat

{

cazul „CSE”:

cazul „CCE”:

System.out.println(„Cursuri opționale: Big Data, Machine Learning”);

pauză;

cazul „ECE”:

System.out.println(„cursuri opționale: Antenna Engineering”);

pauză;

Mod implicit:

System.out.println(„Cursuri opționale: Optimizare”);

}

}

}

}

Ieșire:

Cursuri opționale: Big Data, Machine Learning

Utilizarea șirurilor de caractere în instrucțiunile switch

Începând de la JDK7, puteți utiliza un obiect String în expresia unei instrucțiuni switch. Compararea obiectului șir din expresia instrucțiunii switch cu expresiile asociate fiecărei etichete de caz este ca și cum ar fi folosit metoda String.equals. De asemenea, compararea obiectelor șir în expresia instrucțiunii switch este sensibilă la majuscule și minuscule.

Următorul exemplu de cod afișează tipul de joc pe baza valorii șirului numit „joc”.

clasă publică StringInSwitchStatementExample {

public static void main(String[] args) {

Joc de coarde = „Cricket”;

comuta(joc){

caz „Volei”: carcasă „Fotbal”: carcasă „Cricket”:

System.out.println(„Acesta este un joc în aer liber”);

pauză;

carcasă „Jocuri de cărți”: carcasă „Șah”: carcasă „Puzzle-uri”: carcasă „Baschet de interior”:

System.out.println(„Acesta este un joc de interior”);

pauză;

Mod implicit:

System.out.println(„Ce joc este?”);

}

}

}

Ieșire:

Acesta este un joc în aer liber

Reguli de reținut atunci când utilizați instrucțiuni Java switch

Cel mai bine ar fi să țineți cont de anumite reguli în timp ce utilizați instrucțiuni Java switch . Mai jos este o listă cu aceleași:

• Valoarea pentru un caz și variabila din comutator ar trebui să aibă același tip de date.
• Instrucțiunile de comutare Java nu permit valorile case duplicat.
• O valoare de caz ar trebui să fie literală sau o constantă. Variabilele nu sunt permise.
• Utilizarea instrucțiunii break în interiorul comutatorului încheie o secvență de instrucțiuni.
• Declarația break este opțională și omiterea acesteia va continua execuția în cazul următor.
• Declarația implicită este, de asemenea, opțională și poate apărea oriunde în blocul de comutare. Dacă nu este plasat la sfârșit, trebuie adăugată o instrucțiune break după instrucțiunea implicită pentru a sări peste execuția instrucțiunii case ulterioare.

Pas înainte

Java are o popularitate de neegalat în rândul programatorilor și dezvoltatorilor și este unul dintre cele mai solicitate limbaje de programare în prezent. Inutil să spun că dezvoltatorii în devenire și inginerii de software care doresc să se perfecționeze pentru piața muncii în continuă evoluție trebuie să obțină o fortăreață asupra abilităților lor Java.

Certificarea PG legată de locuri de muncă de la upGrad în inginerie software este special concepută pentru studenții în curs de dezvoltare și candidații de ultimul an care doresc să învețe să codifice și să fie plasați în roluri de software de nivel de intrare.

Dacă vă întrebați ce presupune cursul online de 5 luni, iată câteva momente importante pentru a vă face o idee:

• Câștigă specializări MERN Stack și Cloud-Native
• Aflați abilități de top precum Java, DSA, CSS3, HTML5, AWS, MERN, baze de date SQL și NoSQL și multe altele
• Peste 500 de ore de conținut cu peste 350 de ore de instruire practică
• Cinci proiecte industriale și peste 50 de sesiuni live
• Pregătire pentru plasament și orientare în carieră
• Forumuri de discuții și o rețea puternică de colegi

Dacă vrei să-ți începi călătoria către o carieră promițătoare în inginerie software, iată șansa ta de a învăța de la cei mai buni.