mot-clé case en Java

Le mot-clé case en Java est utilisé dans une instruction switch pour définir un bloc de code qui s'exécute lorsque l'expression du commutateur correspond à une valeur spécifique. Chaque étiquette case doit être unique dans l'instruction de commutation et est suivie de deux points.

Utilisation

Le mot-clé case est utilisé pour traiter des conditions multiples d'une manière plus lisible et plus efficace que plusieurs instructions if-else. Elle est particulièrement utile lorsque vous devez exécuter un code différent en fonction de la valeur d'une variable.

Syntax

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

• expression: La variable ou l'expression évaluée une fois au début de l'instruction de commutation.
• value1value2, etc : Les valeurs constantes auxquelles l'expression est comparée.
• break: Termine le bloc de cas en cours pour éviter les retombées.
• default: Facultatif ; s'exécute si aucune adresse case ne correspond.

Exemples

Exemple 1 : Utilisation de base

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

Dans cet exemple, l'instruction switch évalue la valeur de day. Comme day vaut 3, le bloc de code pour case 3 s'exécute et imprime "mercredi".

Exemple 2 : Utilisation de chaînes de caractères dans Switch

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

Cet exemple illustre l'utilisation d'une déclaration switch avec une déclaration String. L'instruction switch évalue la valeur de fruit. Comme fruit est "Apple", il imprime "Apple is red" (la pomme est rouge).

Exemple 3 : Comportement de repli

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

Dans cet exemple, l'instruction switch évalue la valeur de num. Puisque num est 2, il imprime "Deux" et continue à exécuter "Trois" parce qu'il n'y a pas d'instruction break après case 2.

Exemple 4 : Instructions de commutation imbriquées

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

Cet exemple illustre l'utilisation d'une déclaration imbriquée switch. L'instruction extérieure switch évalue la valeur de outer, tandis que l'instruction intérieure switch évalue la valeur de inner.

Conseils et bonnes pratiques

• Utilisez toujours break: Utilisez l'énoncé break pour éviter tout comportement de repli, à moins que cela ne soit explicitement souhaité.
• Cas par défaut: Prévoyez toujours un cas default pour gérer les valeurs inattendues.
• Valeurs constantes: Veillez à ce que les étiquettes case soient constantes et uniques dans l'instruction de commutation.
• Types de données: les instructions switch peuvent être utilisées avec les types byte, short, int, char, String et enum.
• Simplifiez le code: Utilisez les instructions switch pour simplifier le code qui implique plusieurs conditions, le rendant ainsi plus lisible et plus facile à maintenir.
• Évitez null dans Switch: Soyez prudent avec les valeurs null dans les expressions de commutation afin d'éviter NullPointerException.

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