Java Academy · Lektion

Fall med flera etiketter

Gruppera flera etiketter

Lektion 4 av 413 steg

Fall med flera etiketter är en gratis lektion i Java Academy på CoddyKit. Detta är lektion 4 av 4. Ni kan läsa hela lektionen gratis nedan och sedan öva praktiskt i webbläsaren med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt. Den ingår i lärvägen för Java Academy, och Era framsteg synkroniseras mellan webben och CoddyKit-appen. Kursen i Java Academy innehåller totalt 4 lektioner.

Gruppera etiketter

Ofta ska flera värden utlösa samma åtgärd. Med modern switch kan du ange flera etiketter i samma case, separerade med kommatecken, och låta dem dela på en enda gren.

Etiketter separerade med kommatecken

Skriv värdena efter varandra, separerade med kommatecken, före ->. Om något av dem matchar körs grenen.

public class Main {
    public static void main(String[] args) {
        int day = 7;
        switch (day) {
            case 1, 2, 3, 4, 5 -> System.out.println("Weekday");
            case 6, 7 -> System.out.println("Weekend");
        }
    }
}

Identifiera vokaler

Ett klassiskt användningsområde är att gruppera alla vokaler i en gren i stället för att skriva fem separata case.

public class Main {
    public static void main(String[] args) {
        char c = 'o';
        switch (c) {
            case 'a', 'e', 'i', 'o', 'u' -> System.out.println("Vowel");
            default -> System.out.println("Consonant");
        }
    }
}

Flera etiketter i uttryck

Case med flera etiketter fungerar även i switch-uttryck, där samma värde returneras för alla angivna etiketter.

public class Main {
    public static void main(String[] args) {
        int month = 7;
        String season = switch (month) {
            case 12, 1, 2 -> "Winter";
            case 3, 4, 5 -> "Spring";
            case 6, 7, 8 -> "Summer";
            default -> "Autumn";
        };
        System.out.println(season);
    }
}

Grupperade strängetiketter

Strängvärden kan också grupperas. Här mappas flera stavningar av ett kommando till samma åtgärd.

public class Main {
    public static void main(String[] args) {
        String cmd = "quit";
        switch (cmd) {
            case "quit", "exit", "q" -> System.out.println("Closing");
            case "help", "h" -> System.out.println("Showing help");
            default -> System.out.println("Unknown command");
        }
    }
}

Grupperade enum-etiketter

Enum-konstanter kan också dela på en gren, vilket håller kategorilogiken kompakt.

public class Main {
    enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }
    public static void main(String[] args) {
        Day d = Day.SAT;
        String kind = switch (d) {
            case SAT, SUN -> "Rest";
            default -> "Work";
        };
        System.out.println(kind);
    }
}

Inga dubbla etiketter

Varje etikett får förekomma endast en gång i hela switch-satsen. Om du listar samma värde i två grenar uppstår ett kompileringsfel, eftersom kompilatorn inte skulle kunna avgöra vilken gren som ska köras.

public class Main {
    public static void main(String[] args) {
        int n = 2;
        switch (n) {
            case 1, 2 -> System.out.println("Low");
            case 3, 4 -> System.out.println("High");
            default -> System.out.println("Other");
        }
    }
}

Jämfört med gammal fall-through

I den gamla syntaxen med kolon krävde gruppering tomma fall-through-case staplade ovanför en gemensam kodkropp. Kommasyntaxen är mycket tydligare och förhindrar oavsiktlig fall-through.

public class Main {
    public static void main(String[] args) {
        int code = 3;
        switch (code) {
            case 1, 3, 5, 7, 9 -> System.out.println("Odd");
            case 0, 2, 4, 6, 8 -> System.out.println("Even");
        }
    }
}

Gruppera med block

Ett grupperat case kan också använda en blockkropp. Alla matchande etiketter kör hela blocket.

public class Main {
    public static void main(String[] args) {
        char grade = 'B';
        switch (grade) {
            case 'A', 'B' -> {
                System.out.println("Pass");
                System.out.println("Well done");
            }
            default -> System.out.println("Try again");
        }
    }
}

Kombinera med yield

Grupperade etiketter och yield fungerar tillsammans när en gemensam gren behöver utföra beräkningar.

public class Main {
    public static void main(String[] args) {
        int n = 4;
        int points = switch (n) {
            case 1, 2, 3 -> 10;
            case 4, 5, 6 -> {
                int bonus = n * 2;
                yield 20 + bonus;
            }
            default -> 0;
        };
        System.out.println(points);
    }
}

En tydlig förbättring

Case med flera etiketter ersätter långa listor av upprepade grenar med några få tydliga grupper, så att avsikten framgår direkt.

public class Main {
    public static void main(String[] args) {
        int http = 204;
        String group = switch (http / 100) {
            case 1, 2, 3 -> "OK-ish";
            case 4, 5 -> "Error";
            default -> "Unknown";
        };
        System.out.println(group);
    }
}

Snabb kontroll

Hur får du flera värden att köra samma switch-gren i modern Java?

Besvara frågan i den interaktiva lektionen

Sammanfattning

Du har lärt dig case med flera etiketter:

Lista värden separerade med kommatecken före ->
Fungerar för heltal, tecken, strängar och enum-värden
Ingen oavsiktlig fall-through, till skillnad från den gamla syntaxen
Varje etikett får förekomma endast en gång
Kombinera med block och yield vid behov

Gratis att börja

Lär dig Java med en AI-lärare – gratis

Skriv och kör riktig kod i webbläsaren, få omedelbar hjälp av en AI-lärare dygnet runt och fortsätt där du slutade – på webben eller i appen.

Kurser: 104
Lektioner: 374

Börja lära dig gratis Visa hela kursen

Vanliga frågor

Är lektionen ”Fall med flera etiketter” gratis?

Ja – hela texten till ”Fall med flera etiketter” kan läsas gratis här på webben. Om Ni vill öva interaktivt med en inbyggd kodredigerare och en AI-handledare som är tillgänglig dygnet runt och låsa upp resten av kursen i Java Academy, kan Ni uppgradera till CoddyKit PRO. Kursen i Java Academy innehåller totalt 4 lektioner.

Vad lär jag mig i ”Fall med flera etiketter”?

Gruppera flera etiketter Ni övar på Java Academy med praktisk kod som körs direkt i webbläsaren, medan en AI-handledare som är tillgänglig dygnet runt svarar på Era frågor under lektionen.

Behöver jag någon erfarenhet för att börja lära mig Java Academy?

Du behöver inga förkunskaper. Utbildningen i Java Academy på CoddyKit är upplagd för allt från nybörjare till avancerade elever, så att du kan börja här eller från början och gå fram i din egen takt. Detta är lektion 4 av 4.

Hur lång tid tar lektionen ”Fall med flera etiketter”?

De flesta CoddyKit-lektioner tar cirka 5–10 minuter. Varje lektion är kort och interaktiv, så att du gör stadiga framsteg och kan fortsätta precis där du slutade – på webben eller i appen.

Kan jag skriva och köra kod i den här Java Academy-lektionen?

Ja. Varje Java Academy-lektion innehåller en inbyggd kodredigerare, så att du kan skriva och köra riktig kod direkt i webbläsaren och få omedelbar AI-feedback – utan lokal installation.

Alla lektioner i den här kursen

← Tillbaka till Java Academy