Java Academy · Les

Cases met meerdere labels

Groepeer meerdere labels

Les 4 van 413 stappen

Cases met meerdere labels is een gratis Java Academy-les op CoddyKit. Dit is les 4 van 4. Je kunt de volledige les hieronder gratis lezen en daarna in de browser praktisch oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is. Deze les maakt deel uit van het leertraject Java Academy. Je voortgang wordt gesynchroniseerd op het web en in de CoddyKit-app. De cursus Java Academy bevat in totaal 4 lessen.

Labels groeperen

Vaak moeten verschillende waarden dezelfde actie activeren. Met modern switch kun je meerdere labels in één case opsommen, gescheiden door komma's, zodat ze één tak delen.

Labels gescheiden door komma's

Schrijf de waarden achter elkaar, gescheiden door komma's, vóór ->. Als een van de waarden overeenkomt, wordt de tak uitgevoerd.

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");
        }
    }
}

Klinkers detecteren

Een klassiek gebruik: alle klinkers in één tak groeperen in plaats van vijf afzonderlijke cases te schrijven.

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");
        }
    }
}

Meerdere labels in expressies

Cases met meerdere labels werken ook in switch-expressies. Voor elk van de genoemde labels geven ze dezelfde waarde terug.

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);
    }
}

String-labels groeperen

String-waarden kunnen ook worden gegroepeerd. Hier worden verschillende schrijfwijzen van een opdracht aan één actie gekoppeld.

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");
        }
    }
}

Enum-labels groeperen

Enumconstanten kunnen ook een tak delen, waardoor de logica voor categorieën compact blijft.

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);
    }
}

Geen dubbele labels

Elk label mag maar één keer in de hele switch voorkomen. Als je dezelfde waarde in twee takken opsomt, ontstaat er een compilatiefout, omdat de compiler niet kan bepalen welke tak moet worden uitgevoerd.

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");
        }
    }
}

Vergeleken met oud doorschieten

In de oude stijl met dubbele punten vereiste groeperen lege cases die boven elkaar stonden en naar één gedeeld blok doorschoten. De syntaxis met komma's is veel duidelijker en voorkomt onbedoeld doorschieten.

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");
        }
    }
}

Groeperen met blokken

Een gegroepeerde case kan ook een blok gebruiken. Elk overeenkomend label voert het volledige blok uit.

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");
        }
    }
}

Combineren met yield

Gegroepeerde labels en yield werken goed samen wanneer een gedeelde tak een berekening nodig heeft.

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);
    }
}

Winst voor de leesbaarheid

Cases met meerdere labels verkorten lange lijsten met herhalende takken tot enkele duidelijke groepen, waardoor de bedoeling in één oogopslag duidelijk is.

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);
    }
}

Korte controle

Hoe zorg je er in modern Java voor dat verschillende waarden dezelfde switch-tak uitvoeren?

Beantwoord dit in de interactieve les

Samenvatting

Je hebt cases met meerdere labels geleerd:

Som waarden gescheiden door komma's op vóór ->
Dit werkt voor ints, chars, Strings en enumtypen
Geen onbedoeld doorschieten, in tegenstelling tot de oude stijl
Elk label mag maar één keer voorkomen
Combineer dit indien nodig met blokken en yield

Gratis beginnen

Leer Java met een AI-tutor — gratis

Schrijf echte code en voer die uit in je browser, krijg direct hulp van een AI-tutor die 24/7 beschikbaar is en ga verder waar je gebleven bent op het web of in de app.

Cursussen: 104
Lessen: 374

Gratis beginnen met leren Bekijk de volledige cursus

Veelgestelde vragen

Is de les “Cases met meerdere labels” gratis?

Ja — de volledige tekst van “Cases met meerdere labels” kun je hier gratis op het web lezen. Als je interactief wilt oefenen met een ingebouwde code-editor en een AI-begeleider die 24/7 beschikbaar is, en de rest van de cursus Java Academy wilt ontgrendelen, kun je upgraden naar CoddyKit PRO. De cursus Java Academy bevat in totaal 4 lessen.

Wat leer ik in “Cases met meerdere labels”?

Groepeer meerdere labels Je oefent met Java Academy door code rechtstreeks in de browser uit te voeren. Een AI-begeleider die 24/7 beschikbaar is beantwoordt je vragen terwijl je de les doorwerkt.

Heb ik ervaring nodig om met Java Academy te beginnen?

Ervaring vooraf is niet nodig. Java Academy op CoddyKit is opgebouwd voor beginners tot gevorderden, zodat je hier of bij het begin kunt starten en in je eigen tempo kunt leren. Dit is les 4 van 4.

Hoe lang duurt de les “Cases met meerdere labels”?

De meeste lessen van CoddyKit duren ongeveer 5–10 minuten. Elke les is kort en interactief, zodat je gestaag vooruitgaat en op het web en in de app precies verdergaat waar je was gebleven.

Kan ik code schrijven en uitvoeren in deze les over Java Academy?

Ja. Elke les over Java Academy bevat een ingebouwde code-editor, zodat je rechtstreeks in je browser echte code kunt schrijven en uitvoeren en direct feedback van AI krijgt — lokale installatie is niet nodig.

Alle lessen in deze cursus

← Terug naar Java Academy