Leer Switch-Case-Instructie

Veeg om het menu te tonen

Afhandelen van Meerdere Verschillende Condities

Wanneer er veel condities gecontroleerd moeten worden, is het gebruik van meerdere if-else-ketens mogelijk niet handig.

Bijvoorbeeld:

Main.java


              12345678910111213141516171819
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // You can change the value of the variable `a` to test the `if` statement
        int a = 30;
        if (a == 10) {
            System.out.println(10);
        } else if (a == 20) {
            System.out.println(20);
        } else if (a == 30) {
            System.out.println(30);
        } else if (a == 40) {
            System.out.println(40);
        } else {
        	System.out.println(a);
		}
    }
}

We zien dat dit niet overzichtelijk en professioneel oogt. Voor dergelijke gevallen biedt Java de switch-case-instructie.

switch-case-instructie

De switch-case-instructie bestaat uit verschillende onderdelen:

Main.java


              123456789
            
switch (expression) {
    case value_1: // Code to be executed if expression matches `value_1`
        break; // Break is used to exit the `switch` statement.
    case value_2: // Code to be executed if expression matches `value_2`
        break; // Break is used to exit the `switch` statement.
    ............
    default: // Code to be executed if no cases match
    // Optional, but executed if no other case matches
}

In de bovenstaande code zie je dat we switch-blokken gebruiken om selectief bewerkingen uit te voeren. We vertrouwen op de expressie, die enigszins verschilt van een conditie. Daar plaatsen we een waarde of een expressie in. Bijvoorbeeld, 10 / 2. In dit geval wordt het case-blok met de signatuur case 5 uitgevoerd omdat de bovenstaande expressie gelijk is aan 5.

We kunnen hier ook een conditie gebruiken. In dat geval moeten we een Booleaanse expressie in het expressieblok schrijven, en dat ziet er ongeveer zo uit: 10 / 2 == 5. Schrijf vervolgens twee cases hieronder:

case true:
  
case false:

Maar deze structuur zal bijna niet te onderscheiden zijn van een gewone if-else.

Het sleutelwoord "break"

We gebruiken dit sleutelwoord om de uitvoering van een switch-case-instructie te beëindigen en het blok te verlaten. Dit woord wordt vaak gebruikt in lussen, die we in de volgende hoofdstukken zullen bespreken. Gebruik dit sleutelwoord wanneer je een codeblok wilt verlaten en de uitvoering wilt stoppen.

Laten we nu de code die we hierboven hebben geschreven verbeteren met behulp van de switch-case-instructie:

Main.java


              123456789101112131415161718192021222324
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // You can change the value of the variable `a` to test the `switch` statement
        int a = 30;
        switch (a) {
            case 10:
                System.out.println(10);
                break;
            case 20:
                System.out.println(20);
                break;
            case 30:
                System.out.println(30);
                break;
            case 40:
                System.out.println(40);
                break;
            default:
                System.out.println("There is no matching value");
        }
    }
}

We zien dat de code veel overzichtelijker en gemakkelijker te lezen en uit te breiden is geworden. Het is niet meer nodig om een extra if-instructie helemaal opnieuw te schrijven als er aanvullende voorwaarden nodig zijn. In plaats daarvan kan eenvoudig een extra case-blok aan de switch-case statement worden toegevoegd.

Laten we het schema van het switch-case blok bekijken:

Zoals we kunnen zien, kunnen er zoveel cases zijn als we willen. Elke case vereist een eigen conditie en code, die wordt uitgevoerd wanneer ons programma het case-blok binnenkomt. Het is aan te raden om het break-trefwoord te gebruiken, omdat het programma het switch-blok niet verlaat totdat alle case-blokken zijn uitgevoerd. Het default-blok wordt uitgevoerd als we geen van onze case-blokken zijn binnengegaan of het break-trefwoord niet hebben gebruikt.

Laten we naar een ander voorbeeld kijken zonder break-trefwoorden:

Main.java


              1234567891011121314151617181920
            
package com.example;

public class Main {
    public static void main(String[] args) {
        // You can change the value of the variable `a` to test the `switch` statement
        int a = 10;
        switch (a) {
            case 10:
                System.out.println(10);
            case 20:
                System.out.println(20);
            case 30:
                System.out.println(30);
            case 40:
                System.out.println(40);
            default:
                System.out.println("There is no matching value");
        }
    }
}

We hebben meerdere waarden ontvangen die afwijken van wat we verwachtten. Daarnaast hebben we informatie verkregen uit de blokken case 10 en default. Dit is precies de reden waarom we het sleutelwoord break na elk blok gebruiken. Op deze manier verlaat het programma de switch-instructie en gaat het verder met de uitvoering.