Switch kifejezés versus switch utasítás

Ha sok feltételt tartalmazó kódot írsz, akkor minden bizonnyal if-else vagy switch utasítást használtál . De ennek az if-else alternatívának vannak hátrányai. Vannak, akik a switch utasítást "antimintának" is nevezték .

De van egy jó hír: a Java új verziói sok változást hoztak a nyelv szintaxisában, és az egyik változás a switchet érinti . Érdekelt? Akkor merüljünk bele.

Először is érdemes tisztázni, hogy a kapcsoló miért antiminta. Vegye figyelembe a következő kódot:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    default:
        seasonNumber = 0;
}

Oké, tehát még nem teljesen világos, hogy ez miért „antiminta”.

De mi van, ha további esetblokkokat adunk hozzá , és most a kód így néz ki:

switch (condition) {
    case "DECEMBER":
        seasonNumber = 1;
        break;
    case "JANUARY":
        seasonNumber = 1;
        break;
    case "FEBRUARY":
        seasonNumber = 1;
        break;
    case “MARCH”:
        seasonNumber = 2;
        break;
    case “APRIL”:
        seasonNumber = 2;
        break;
    case “MAY”:
        seasonNumber = 2;
        break;
    default:
        seasonNumber = 0;
}

Adjunk hozzá még néhány sort – a kód meghosszabbodik. Később újabb és újabb sorokat vehetünk fel, és ebben senki sem akadályoz meg bennünket.

Ez a probléma lényege: miután kezdetben létrehoztunk egy kompakt switch utasítást, egyre több kódot adunk hozzá, egyre több helyet foglalva – többet, mint amennyi elfér a képernyőn –, és kényelmetlenné teszi a kód olvasását és karbantartását.

A switch utasítás és a switch kifejezés közötti különbség

A Java 14 új és továbbfejlesztett kapcsolót vezetett be. Ez nem egy switch utasítás , hanem egy switch kifejezés .

Mi a különbség, kérdezed? A különbség az, hogy az utasítás egy utasítás, amely bizonyos műveleteket hajt végre, a kifejezés viszont egy kódrészlet, amely valamilyen számítást végez, és eredményt ad vissza.

Más szóval, most elmentheti egy változóra való váltás eredményét.

Elég beszélni. Most pedig nézzük meg, hogyan néz ki az új kapcsoló :

var result = switch(month) {
     case DECEMBER, JANUARY, FEBRUARY -> 1;
     case MARCH, APRIL, MAY -> 2;
    case JUNE, JULY, AUGUST -> 3;
    case SEPTEMBER, OCTOBER, NOVEMBER -> 4;
    default -> 0; 
};

Az első dolog, ami megragadja a figyelmet, az, hogy milyen kompakt a kód. A korábban a képernyő nagy részét elfoglaló kód most néhány sort ölel fel, és sokkal olvashatóbbnak tűnik.

-> operátor

Figyelembe kell venni a -> operátort is (nyíl operátor). Lehet, hogy már ismeri, ha van tapasztalata a lambda kifejezésekkel.

Ez azt jelenti, hogy most már írhat egy menő kinézetű kapcsolót a lambda-állítás stílusában. A nyíl operátor azt jelzi, hogy a fordító nem lép tovább a következő esetkifejezésre (ha az aktuális esetblokkból hiányzik a break vagy a return utasítás), hanem a nyíltól jobbra lévő kifejezés értékét adja meg.

Olyan kódot is írhat, amely nem kifejezés, és egyszerűen végrehajt bizonyos műveleteket ahelyett, hogy bármit visszaadna:

switch(condition) {
    case TRUE, FALSE -> System.out.println("True/false");
  
    default -> System.out.println("Another");
}

Vegye figyelembe, hogy a kapcsolónak már nincs break utasítása. A Java 13-ban eltávolították, és a hozamra cserélték .

Mi a hozam és hol használható?

Ha egy kapcsoló egyetlen sorból áll, maga a -> operátor adja vissza az értéket. De mi van akkor, ha nem egy, hanem sok kódsorunk van? Ilyen esetekben a nyíl operátor nem ad vissza értéket, mivel több sor van, nem egy.

Talán használhatjuk a return-t ? Végül is a Java értékek visszaadására szolgál. Jaj, nem, a visszatérés nem működik kapcsolóval. Tehát mit használhatunk? Régebben volt a break , de a Java 13-ban eltávolították. De a helyén most a hozam van – egy új kulcsszó, amely segít visszaadni egy értéket egy kapcsolóból. Ez analóg a metódusokban lévő utasításokkal.

var result = switch(condition) {
//…
case "Hi" -> "greeting"
//…
};  

Ez a kód egyetlen sort tartalmaz, és a -> operátor a "köszönést" adja vissza.

De ha van egy kódblokk:

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 Here you need to return "greeting"
	}
};  

A kulcsszó, amely segít visszaadni egy értéket, a hozam :

var result = switch(condition) {
//…
case "Hi" -> {
// Your code
 yield "greeting";

	}
};

A hozam hozzáadásra került a Java 13-ban olyan esetekben, amikor egynél több kódsor van egy esetblokkban, és eredményt kell visszaadnunk.

Valószínűleg szívesen kipróbálná az új kapcsolót a kódjában, de ne feledje, hogy ehhez Java 14 vagy újabb verzióra van szüksége. A korábbi verzióknál ez a váltás csak akkor lesz elérhető, ha a parancssorban megadjuk az "--enable-preview" jelzőt, mivel a 14-es verzió előtt a technikai előnézet része volt, nem pedig a nyelv teljes értékű része.

Ez minden most! Találkozunk!