Java Academy · Leçon

switch comme expression

Renvoyer des valeurs depuis switch

switch comme expression est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 2 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Instructions et expressions

Une instruction effectue une action. Une expression produit une valeur. Java moderne permet d'utiliser switch comme une expression, afin d'affecter directement son résultat à une variable.

Affecter le résultat d'un switch

Lorsque switch apparaît à droite de =, chaque branche fournit la valeur. La forme fléchée renvoie automatiquement la valeur située après ->.

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

Point-virgule après le bloc

Comme une expression switch fait partie d'une instruction, celle-ci se termine par un point-virgule après l'accolade fermante. L'oublier est une erreur de compilation fréquente.

public class Main {
    public static void main(String[] args) {
        int n = 2;
        int doubled = switch (n) {
            case 1 -> 2;
            case 2 -> 4;
            default -> 0;
        };
        System.out.println(doubled);
    }
}

Exhaustivité

Une expression switch doit couvrir toutes les valeurs possibles. Pour la plupart des types, cela signifie inclure une branche default, faute de quoi le code ne compilera pas.

public class Main {
    public static void main(String[] args) {
        int score = 85;
        char grade = switch (score / 10) {
            case 10, 9 -> 'A';
            case 8 -> 'B';
            case 7 -> 'C';
            default -> 'F';
        };
        System.out.println(grade);
    }
}

Les énumérations n'ont pas besoin de default

Lorsque vous utilisez switch sur une enum et couvrez chaque constante, le compilateur sait que l'expression est exhaustive. Une branche default devient facultative.

public class Main {
    enum Dir { NORTH, SOUTH, EAST, WEST }
    public static void main(String[] args) {
        Dir d = Dir.EAST;
        String label = switch (d) {
            case NORTH -> "Up";
            case SOUTH -> "Down";
            case EAST -> "Right";
            case WEST -> "Left";
        };
        System.out.println(label);
    }
}

Renvoyer directement

Une méthode peut renvoyer directement une expression switch avec return, ce qui permet de créer des méthodes de recherche concises.

public class Main {
    static int sides(String shape) {
        return switch (shape) {
            case "triangle" -> 3;
            case "square" -> 4;
            case "pentagon" -> 5;
            default -> 0;
        };
    }
    public static void main(String[] args) {
        System.out.println(sides("square"));
    }
}

Résultats numériques

Les branches peuvent renvoyer des nombres, effectuer des calculs ou appeler des méthodes. Chaque branche doit produire une valeur du même type que la variable à laquelle elle est affectée.

public class Main {
    public static void main(String[] args) {
        int month = 2;
        int days = switch (month) {
            case 2 -> 28;
            case 4, 6, 9, 11 -> 30;
            default -> 31;
        };
        System.out.println("Days: " + days);
    }
}

Utiliser le résultat directement

La valeur produite par une expression switch peut être utilisée immédiatement, par exemple dans un appel à println.

public class Main {
    public static void main(String[] args) {
        int code = 1;
        System.out.println("Status: " + switch (code) {
            case 0 -> "OK";
            case 1 -> "Warning";
            default -> "Error";
        });
    }
}

Cohérence des types

Toutes les branches doivent avoir le même type de résultat. Si une branche renvoie un int et une autre un String, le code ne compilera pas. Veillez à conserver le même type dans toutes les branches.

public class Main {
    public static void main(String[] args) {
        int n = 3;
        double factor = switch (n) {
            case 1 -> 0.5;
            case 2 -> 1.0;
            default -> 1.5;
        };
        System.out.println(factor);
    }
}

Remplacer les enchaînements ternaires

Une expression switch est souvent plus claire que des opérateurs ternaires imbriqués lorsqu'elle associe une valeur à plusieurs résultats.

public class Main {
    public static void main(String[] args) {
        int rating = 4;
        String stars = switch (rating) {
            case 1 -> "*";
            case 2 -> "**";
            case 3 -> "***";
            case 4 -> "****";
            default -> "*****";
        };
        System.out.println(stars);
    }
}

Combiner avec des variables

Vous pouvez utiliser le résultat d'une expression switch dans d'autres calculs, comme n'importe quelle autre valeur.

public class Main {
    public static void main(String[] args) {
        int tier = 2;
        int discount = switch (tier) {
            case 1 -> 5;
            case 2 -> 10;
            default -> 0;
        };
        int price = 100 - discount;
        System.out.println("Price: " + price);
    }
}

Vérification rapide

Pourquoi une expression switch doit-elle généralement inclure une branche default ?

Récapitulatif

Vous avez appris à utiliser switch comme une expression :

Elle produit une valeur que vous pouvez affecter ou renvoyer
Terminer l'affectation par un point-virgule
Elle doit être exhaustive (elle nécessite généralement default)
Les énumérations couvrant toutes les constantes n'ont pas besoin de default
Toutes les branches doivent avoir le même type de résultat

Questions Fréquemment Posées

La leçon « switch comme expression » est-elle gratuite ?

Oui — le texte complet de « switch comme expression » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « switch comme expression » ?

Renvoyer des valeurs depuis switch Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 2 sur 4.

Combien de temps prend la leçon « switch comme expression » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy