case Schlüsselwort in Java

Das Schlüsselwort case wird in Java innerhalb einer switch Anweisung verwendet, um einen Codeblock zu definieren, der ausgeführt wird, wenn der Switch-Ausdruck auf einen bestimmten Wert trifft. Jedes case Label muss innerhalb der Switch-Anweisung eindeutig sein und wird von einem Doppelpunkt gefolgt.

Verwendung

Das Schlüsselwort case wird verwendet, um mehrere Bedingungen auf eine lesbarere und effizientere Weise zu behandeln als mehrere if-else Anweisungen. Sie ist besonders nützlich, wenn du je nach dem Wert einer Variablen unterschiedlichen Code ausführen musst.

Syntax

switch (expression) {
    case value1:
        // code block
        break;
    case value2:
        // code block
        break;
    // more cases...
    default:
        // default code block
}

• expression: Die Variable oder der Ausdruck, der am Anfang der Switch-Anweisung einmal ausgewertet wird.
• value1, value2, etc.: Die konstanten Werte, mit denen der Ausdruck verglichen wird.
• break: Beendet den aktuellen Fallblock, um ein Durchfallen zu verhindern.
• default: Optional; wird ausgeführt, wenn keine case übereinstimmt.

Beispiele

Beispiel 1: Grundlegende Verwendung

public class SwitchExample {
    public static void main(String[] args) {
        int day = 3;
        switch (day) {
            case 1:
                System.out.println("Monday");
                break;
            case 2:
                System.out.println("Tuesday");
                break;
            case 3:
                System.out.println("Wednesday");
                break;
            case 4:
                System.out.println("Thursday");
                break;
            case 5:
                System.out.println("Friday");
                break;
            case 6:
                System.out.println("Saturday");
                break;
            case 7:
                System.out.println("Sunday");
                break;
            default:
                System.out.println("Invalid day");
        }
    }
}

In diesem Beispiel wertet die Anweisung switch den Wert von day aus. Da day 3 ist, wird der Codeblock für case 3 ausgeführt und "Mittwoch" gedruckt.

Beispiel 2: Strings in Switch verwenden

public class SwitchStringExample {
    public static void main(String[] args) {
        String fruit = "Apple";
        switch (fruit) {
            case "Apple":
                System.out.println("Apple is red.");
                break;
            case "Banana":
                System.out.println("Banana is yellow.");
                break;
            case "Orange":
                System.out.println("Orange is orange.");
                break;
            default:
                System.out.println("Unknown fruit.");
        }
    }
}

Dieses Beispiel demonstriert die Verwendung einer switch Anweisung mit einer String. Die Anweisung switch wertet den Wert von fruit aus. Da fruit "Apfel" ist, wird "Apfel ist rot" gedruckt.

Beispiel 3: Fall-through-Verhalten

public class FallThroughExample {
    public static void main(String[] args) {
        int num = 2;
        switch (num) {
            case 1:
                System.out.println("One");
            case 2:
                System.out.println("Two");
            case 3:
                System.out.println("Three");
                break;
            default:
                System.out.println("Default");
        }
    }
}

In diesem Beispiel wertet die Anweisung switch den Wert von num aus. Da num gleich 2 ist, wird "Zwei" gedruckt und dann mit der Ausführung von "Drei" fortgefahren, da es keine break Anweisung nach case 2 gibt.

Beispiel 4: Verschachtelte Switch-Anweisungen

public class NestedSwitchExample {
    public static void main(String[] args) {
        int outer = 1;
        int inner = 2;
        switch (outer) {
            case 1:
                switch (inner) {
                    case 1:
                        System.out.println("Inner 1");
                        break;
                    case 2:
                        System.out.println("Inner 2");
                        break;
                }
                break;
            case 2:
                System.out.println("Outer 2");
                break;
            default:
                System.out.println("Default Outer");
        }
    }
}

Dieses Beispiel demonstriert die Verwendung einer verschachtelten switch Anweisung. Die äußere Anweisung switch wertet den Wert von outer aus, während die innere Anweisung switch den Wert von inner auswertet.

Tipps und bewährte Praktiken

• Verwende immer break: Verwende die Anweisung break, um ein Durchfallen zu vermeiden, es sei denn, es ist ausdrücklich erwünscht.
• Standardfall: Füge immer einen default Fall ein, um unerwartete Werte zu behandeln.
• Konstante Werte: Achte darauf, dass die case Bezeichnungen Konstanten sind und innerhalb der switch-Anweisung eindeutig sind.
• Datentypen: switch Anweisungen können mit den Typen byte, short, int, char, String und enum verwendet werden.
• Simplify Code: Verwende die switch Anweisungen, um Code zu vereinfachen, der mehrere Bedingungen enthält, damit er besser lesbar und wartbar ist.
• Vermeide null in Switch: Sei vorsichtig mit null Werten in Switch-Ausdrücken, um NullPointerException zu verhindern.

switch (expression) {
    case constant1:
        // code block
        break;
    case constant2:
        // code block
        break;
    // more cases...
    default:
        // default code block
}