Switch utasítások ebben a kurzusban:

A(z) Switch utasítások fogalomról

Az if/else elágazáshoz hasonlóan a switch utasítás is lehetővé teszi, hogy feltételesen hajts végre kódot, és ezzel megváltoztasd a program vezérlési folyamát. A különbség az, hogy a switch utasítás csak primitív vagy string kifejezés értékét tudja összehasonlítani előre meghatározott konstans értékekkel.

Néhány kulcsszó hasznos lehet, amikor switch utasítást használsz.

• switch: ezzel a kulcsszóval deklarálhatod a switch szerkezetét. Utána az a kifejezés vagy változó következik, amelyik megváltoztatja az eredményt.
• case: ezzel fogod deklarálni az eredmény lehetséges változatait.
• break: a break kulcsszó nagyon hasznos, hogy a kívánt folyamat végén leállítsd a switch végrehajtását. Ha elfelejted, a program folytatódik, és váratlan eredményekhez vezethet.
• default: ahogy a neve is mondja, alapértelmezett eredményként használd, amikor egyetlen másik case sem illeszkedik a kifejezésed eredményére.

A legegyszerűbb formájukban egy primitív vagy string kifejezést tesztelnek, és annak értéke alapján döntenek. Például:

String direction = getDirection();
switch (direction) {
    case "left":
        goLeft();
        break;
    case "right":
        goRight();
        break;
    default:
        // otherwise
        markTime();
        break;
}

A Java 14-től kezdve (Java 12-ben és 13-ban még előzetesként volt elérhető) használható a „továbbfejlesztett” switch-megvalósítás.

1. Lehetőséged van több értéket hozzárendelni egyetlen case-hez. A hagyományos switch-utasításban használhatod az átesést. A következő példában a case 1 és a case 3 ugyanazt fogja végrehajtani. Ezt az teszi lehetővé, hogy a case 1 nem használja a break kulcsszót.

   switch (number) {
       case 1:
       case 3:
           // do same stuff
           break;
       case 2:
           // do different stuff
           break;
       // (...)
   }
   

   A továbbfejlesztett switch expression esetén közvetlenül több értéket rendelhetsz egy case-hez. Nézd meg a következő példát:

   switch (number) {
       case 1, 3:
           // do stuff
           break;
       case 2:
           // do other stuff
           break;
       // (...)
   }
   

2. Most már írhatsz switch-statement-et vagy switch expression-t. Mi a különbség? Alapvetően az utasítás szigorú logikát vár el, míg a kifejezés visszaadhat egy értéket. Ahelyett, hogy:

   String result = "";
   switch (expression) {
       case "bob":
           result = "bob";
           break;
       // (...)
   }
   

   Ezt is teheted:

   String result = switch (expression) {
       case "bob":
           yield "bob";
       // (...)
   }
   

   A yield úgy működik, mint a return, azzal a különbséggel, hogy switch-kifejezéshez való. Mivel a yield lezárja a kifejezést, itt nincs szükség a break kulcsszóra.

3. Egy másik különbség a switch-utasítások és a switch-kifejezések között: a switch-kifejezésekben MUSZÁJ minden esetet lefedned. Akár úgy, hogy minden lehetséges értékhez külön case-t adsz, akár egy default ág használatával.

4. A : helyett használhatod a ->-t. A -> lehetővé teszi, hogy kihagyd a break kulcsszót. Mindkét jelölés használható, de egy switch-en belül csak az egyik mellett maradhatsz.

    switch(expression) {
        case 1 -> yield "one"
        case 2 -> yield "two"
        default: yield "other number" // Removing this will result in a compile error
    }
   

5. A scope. A hagyományos switch a scope miatt váratlan viselkedést okozhat, mivel az egész switch-hez csak egy scope tartozik.

    switch(expression) {
        case 1:
            String message = "something";
            break;
        case 2:
            String message = "anything";
            break;
        // (...)
    }
   

   Ez a példa azért nem működik, mert a message kétszer szerepel a switch-ben. Megoldható így:

    switch (expression) {
        case 1: {
            String message = "something";
            break;
        }
        case 2: {
            String message = "anything";
            break;
        }
        // (...)
    }
   

   Mivel a {} határolja a case scope-ját. Ez azonban nem intuitív, mert a {} nem kötelező. Ha viszont az új -> jelölést használod, akkor csak egyetlen utasítás/kifejezés, egy throw utasítás vagy egy {} blokk következhet utána. Nincs több zűrzavar!

A továbbfejlesztett switchről több információt ebben a cikkben és ebben találsz, valamint a hivatalos Oracle-dokumentációban.

Ezenkívül a Java 21-ben megjelent egy Guarded Patterns nevű szolgáltatás, amely lehetővé teszi, hogy ellenőrzéseket végezz a case címkében.

String dayOfMonth = getDayOfMonth();
String day = "";
return switch (day) {
    case "Tuesday" when dayOfMonth == 13 -> "Forbidden day!!";
    case "Monday", "Tuesday", "Wednesday", "Thursday", "Friday" -> "Week day";
    case "Saturday", "Sunday" -> "Weekend";
    default -> "Unknown";
};

A Java 21-es switch-kifejezésről többet ebben a blogbejegyzésben olvashatsz.