1. Quoi de neuf dans switch
Si vous avez programmé en Java avant la version 14, alors switch ressemblait à peu près à ceci :
switch (day)
{
case MONDAY:
System.out.println("Début de semaine !");
break;
case FRIDAY:
System.out.println("Vendredi, youpi !");
break;
default:
System.out.println("Journée ordinaire.");
break;
}
Rien de dramatique, mais :
- Il ne faut pas oublier break (sinon on « tombe » dans le case suivant).
- Beaucoup de code répétitif.
- Si vous voulez renvoyer une valeur, vous devez déclarer une variable à l’avance et lui affecter la valeur à l’intérieur de chaque case.
Java 14+ a tranché : ça suffit ! Il est temps de rendre switch plus pratique et moderne.
Nouveautés principales :
- Switch est devenu une expression, et pas seulement une instruction — il peut désormais renvoyer une valeur.
- Nouvelle syntaxe avec flèche -> au lieu des deux-points et de break.
- Plusieurs case séparés par des virgules — pour une logique identique.
- Le compilateur vérifie que tous les cas sont couverts (en particulier avec les enum).
- Pas de risque de « fall-through » — désormais, c’est seulement possible explicitement.
2. Syntaxe des expressions switch
switch (value)
{
case A, B -> result1;
case C -> {
// plusieurs actions
yield result2;
}
default -> defaultResult;
}
-> et
yield
Exemple de base
Allons droit au but. Voici comment renvoyer une valeur depuis switch désormais :
DayOfWeek day = DayOfWeek.MONDAY;
String message = switch (day)
{
case MONDAY, FRIDAY, SUNDAY -> "Semaine courte ou jour de repos !";
case TUESDAY -> "Le mardi — une journée difficile.";
case WEDNESDAY, THURSDAY -> "Milieu de semaine !";
case SATURDAY -> "Youpi, samedi !";
// default est obligatoire si toutes les possibilités ne sont pas couvertes
default -> "Jour plutôt étrange...";
};
System.out.println(message);
Ce qui se passe ici :
- switch (day) — une expression qui renvoie une valeur.
- Après la flèche -> on indique le résultat pour ce case.
- Plusieurs case peuvent être regroupés par des virgules.
- Il n’y a aucun break — Java sait elle-même où se termine la branche.
- On peut affecter directement le résultat à la variable message.
Exemple avec des nombres
int code = 404;
String result = switch (code)
{
case 200 -> "OK";
case 400, 404 -> "Erreur côté client";
case 500 -> "Erreur serveur";
default -> "Code inconnu";
};
System.out.println(result);
Exemple avec des chaînes
String command = "start";
String status = switch (command)
{
case "start" -> "Démarrage !";
case "stop" -> "Arrêt !";
case "pause" -> "Pause...";
default -> "Commande inconnue";
};
System.out.println(status);
Utilisation d’un bloc avec yield
Parfois, on souhaite exécuter plusieurs actions pour un même case (par exemple, effectuer un calcul complexe ou journaliser). Pour cela, on peut utiliser un bloc { ... } et le mot-clé yield :
int n = 7;
String parity = switch (n % 2)
{
case 0 -> "Pair";
case 1 ->
{
System.out.println("Nombre impair détecté : " + n);
yield "Impair";
}
default -> "Quelque chose d'étrange";
};
System.out.println(parity);
Important : dans un bloc, il doit impérativement y avoir un yield qui renvoie la valeur pour ce case.
3. Avantages de la nouvelle syntaxe
Plus besoin de break
Dans le switch classique, oublier break est une source de douleur et de bugs mystérieux. Avec la nouvelle syntaxe, break n’est plus nécessaire du tout : chaque branche se termine automatiquement.
Le compilateur vérifie la couverture de tous les cas
Si vous utilisez un enum et que vous ne traitez pas toutes les valeurs, le compilateur n’autorisera pas la construction du projet sans default. Cela rend le code plus fiable.
Pas de « fall-through »
Dans le switch classique, si vous oubliez break, l’exécution « tombe » dans le case suivant. Avec la nouvelle syntaxe, c’est impossible (sauf si vous utilisez un bloc d’instructions et écrivez explicitement break — mais ici il n’est pas nécessaire).
Code plus compact et lisible
Comparez :
Avant :
String result;
switch (status) {
case "OK":
result = "Tout va bien";
break;
case "ERROR":
result = "Erreur";
break;
default:
result = "Inconnu";
break;
}
Après :
String result = switch (status) {
case "OK" -> "Tout va bien";
case "ERROR" -> "Erreur";
default -> "Inconnu";
};
Plusieurs case — une même logique
case MONDAY, FRIDAY, SUNDAY -> "Jour de repos ou journée courte !";
4. Comparaison avec le switch classique
| Caractéristique | Switch classique | Nouveau switch |
|---|---|---|
| break obligatoire | Oui | Non |
| Fall-through | Oui | Non |
| Peut retourner une valeur | Non (via une variable seulement) | Oui (expression) |
| Plusieurs case séparés par des virgules | Non | Oui |
| Vérification de tous les cas | Non | Oui (surtout avec enum) |
| Compacité | Beaucoup de code | Court et clair |
| Utilisation avec enum et chaînes | Oui | Oui |
5. Compatibilité avec enum et chaînes
Exemple avec enum
Supposons que nous ayons une énumération :
enum DayOfWeek
{
MONDAY, TUESDAY, WEDNESDAY, THURSDAY, FRIDAY, SATURDAY, SUNDAY
}
Utilisons-la dans le nouveau switch :
DayOfWeek today = DayOfWeek.WEDNESDAY;
String mood = switch (today)
{
case MONDAY -> "Difficile de se lever...";
case FRIDAY -> "Le week-end approche !";
case SATURDAY, SUNDAY -> "Youpi, repos !";
default -> "Jour ouvré.";
};
System.out.println(mood);
Exemple avec String
String season = "summer";
String activity = switch (season)
{
case "winter" -> "Faire du patin à glace";
case "summer" -> "Nager dans le lac";
case "autumn" -> "Cueillir des champignons";
case "spring" -> "Écouter le chant des oiseaux";
default -> "Saison inconnue";
};
System.out.println(activity);
6. Réécrire l’ancien switch dans le nouveau style
Avant :
int day = 3;
String dayName;
switch (day)
{
case 1:
dayName = "Lundi";
break;
case 2:
dayName = "Mardi";
break;
case 3:
dayName = "Mercredi";
break;
default:
dayName = "Jour inconnu";
break;
}
System.out.println(dayName);
Après :
int day = 3;
String dayName = switch (day)
{
case 1 -> "Lundi";
case 2 -> "Mardi";
case 3 -> "Mercredi";
default -> "Jour inconnu";
};
System.out.println(dayName);
Autre exemple : plusieurs case — une même logique
int score = 5;
String grade = switch (score)
{
case 5, 6, 7 -> "Bien";
case 8, 9, 10 -> "Excellent";
default -> "Il faut faire des efforts";
};
System.out.println(grade);
7. Erreurs courantes et particularités
Erreur n° 1 : absence de default si tous les cas ne sont pas couverts. Si vous utilisez une switch-expression avec un type pouvant avoir des valeurs en dehors des case énumérés (par exemple avec un int ou une String), le compilateur exigera un default. Pour les enum, si vous ne couvrez pas toutes les valeurs, default est également obligatoire.
Erreur n° 2 : oubli de yield dans le bloc. Si vous utilisez des accolades pour un case (plusieurs actions à exécuter), n’oubliez pas le yield — sans lui, le compilateur générera l’erreur : "Missing yield statement".
Erreur n° 3 : incompatibilité de types. Toutes les branches d’une switch-expression doivent renvoyer des valeurs du même type ; sinon, le compilateur refusera le code.
Erreur n° 4 : duplication de valeurs de case. Il est interdit d’indiquer deux fois le même case — le compilateur signalera immédiatement une erreur.
GO TO FULL VERSION