Définir et utiliser des énumérations
Déclarez des types enum, utilisez leurs constantes et parcourez-les avec values() et ordinal().
Définir et utiliser des énumérations est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.
Définir et utiliser des énumérations
Une énumération est une classe spéciale qui représente un ensemble fixe de constantes. Les énumérations sont sûres du point de vue des types, lisibles et plus puissantes que les constantes statiques de type int.
Déclarer une énumération
Utilisez le mot-clé enum pour déclarer une énumération. Chaque constante est implicitement public static final et constitue une instance du type d'énumération.
enum Day {
MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
FRIDAY, SATURDAY, SUNDAY
}
Day today = Day.WEDNESDAY;
System.out.println(today); // WEDNESDAY
System.out.println(today.name()); // WEDNESDAY
System.out.println(today.ordinal()); // 2 (zero-based index)Parcourir avec values()
EnumType.values() renvoie toutes les constantes dans l'ordre de leur déclaration. Utilisez-le pour les parcourir ou créer des menus.
enum Planet { MERCURY, VENUS, EARTH, MARS, JUPITER, SATURN, URANUS, NEPTUNE }
for (Planet p : Planet.values()) {
System.out.println(p.ordinal() + ": " + p);
}
// 0: MERCURY
// 1: VENUS
// 2: EARTH
// ...
// Count constants
System.out.println(Planet.values().length); // 8valueOf() et analyse syntaxique
Enum.valueOf(name) convertit une String en constante correspondante. La méthode lève une IllegalArgumentException si elle est introuvable.
enum Status { PENDING, ACTIVE, SUSPENDED, CLOSED }
String input = "ACTIVE";
Status s = Status.valueOf(input);
System.out.println(s); // ACTIVE
try {
Status bad = Status.valueOf("UNKNOWN");
} catch (IllegalArgumentException e) {
System.out.println("Invalid status: UNKNOWN");
}
// Safe parse pattern
static Status safeFrom(String name) {
try { return Status.valueOf(name.toUpperCase()); }
catch (IllegalArgumentException e) { return Status.PENDING; }
}Utiliser les énumérations dans une instruction de sélection
Les énumérations fonctionnent parfaitement dans les instructions et expressions de sélection. Les expressions de sélection modernes rendent la sélection selon une énumération concise et exhaustive.
enum OrderStatus { CREATED, PROCESSING, SHIPPED, DELIVERED, CANCELLED }
OrderStatus status = OrderStatus.SHIPPED;
String message = switch (status) {
case CREATED -> "Order received, awaiting payment";
case PROCESSING -> "Payment confirmed, preparing shipment";
case SHIPPED -> "On the way — track your package";
case DELIVERED -> "Delivered! Enjoy your order";
case CANCELLED -> "Order cancelled";
};
System.out.println(message); // On the way — track your packageÉnumérations avec des conditions
Utilisez == pour comparer les constantes d'une énumération : ce sont des instances uniques, donc la comparaison des références fonctionne correctement.
enum UserRole { GUEST, MEMBER, ADMIN, SUPERADMIN }
UserRole role = UserRole.ADMIN;
if (role == UserRole.ADMIN || role == UserRole.SUPERADMIN) {
System.out.println("Access granted to admin panel");
} else {
System.out.println("Access denied");
}
// Enum comparison: never use .equals() for enums
// == is correct and more readableÉnumérations dans les collections
Les énumérations peuvent être stockées dans les collections standard. Utilisez EnumSet et EnumMap pour un stockage basé sur les énumérations et performant (ce sujet sera abordé dans une leçon ultérieure).
import java.util.*;
enum Permission { READ, WRITE, DELETE, ADMIN }
Set<Permission> userPerms = new HashSet<>();
userPerms.add(Permission.READ);
userPerms.add(Permission.WRITE);
System.out.println(userPerms.contains(Permission.DELETE)); // false
System.out.println(userPerms.contains(Permission.READ)); // true
List<Permission> allPerms = Arrays.asList(Permission.values());
System.out.println(allPerms.size()); // 4Les énumérations implémentent des interfaces
Les énumérations peuvent implémenter des interfaces, ce qui vous permet d'associer un comportement à chaque constante ou de définir un contrat commun pour toutes les constantes.
interface Describable {
String describe();
}
enum Season implements Describable {
SPRING, SUMMER, FALL, WINTER;
public String describe() {
return switch (this) {
case SPRING -> "Mild and rainy";
case SUMMER -> "Hot and sunny";
case FALL -> "Cool with falling leaves";
case WINTER -> "Cold and snowy";
};
}
}
for (Season s : Season.values()) {
System.out.println(s + ": " + s.describe());
}L'énumération comme machine à états
Les énumérations conviennent naturellement aux machines à états. Chaque constante représente un état et les méthodes définissent les transitions valides.
enum TrafficLight {
RED, YELLOW, GREEN;
public TrafficLight next() {
return switch (this) {
case RED -> GREEN;
case GREEN -> YELLOW;
case YELLOW -> RED;
};
}
}
TrafficLight light = TrafficLight.RED;
for (int i = 0; i < 6; i++) {
System.out.println(light);
light = light.next();
}
// RED, GREEN, YELLOW, RED, GREEN, YELLOWBonnes pratiques pour les énumérations
Suivez ces bonnes pratiques lorsque vous utilisez des énumérations :
- Utilisez des noms en majuscules avec des traits de soulignement pour les constantes (convention)
- Préférez les énumérations aux constantes de type int ou String pour garantir la sûreté des types
- Utilisez des expressions de sélection pour garantir la prise en charge de tous les cas
- Ajoutez des champs et des méthodes aux énumérations lorsque les constantes contiennent des données
Pratique : codes d'état HTTP
Une énumération réaliste qui modélise les catégories de codes d'état HTTP avec une méthode de fabrique à partir du code numérique.
enum HttpStatus {
OK(200), CREATED(201), BAD_REQUEST(400),
UNAUTHORIZED(401), NOT_FOUND(404), SERVER_ERROR(500);
public final int code;
HttpStatus(int code) { this.code = code; }
public static HttpStatus from(int code) {
for (HttpStatus s : values())
if (s.code == code) return s;
throw new IllegalArgumentException("Unknown HTTP code: " + code);
}
public boolean isSuccess() { return code >= 200 && code < 300; }
}
HttpStatus s = HttpStatus.from(404);
System.out.println(s + " (" + s.code + ") success=" + s.isSuccess());
// NOT_FOUND (404) success=falseVérification rapide
Quel est le résultat du code suivant ?
enum Color { RED, GREEN, BLUE }
System.out.println(Color.GREEN.ordinal());Récapitulatif : définir et utiliser des énumérations
Points essentiels :
- Les énumérations définissent un ensemble fixe de constantes nommées tout en garantissant la sûreté des types
- values() parcourt toutes les constantes ; ordinal() fournit l'indice commençant à zéro
- valueOf() convertit une String en constante correspondante
- Utilisez == (et non equals) pour comparer des instances d'énumération
- Les énumérations fonctionnent très bien dans les expressions de sélection pour garantir la prise en charge de tous les cas
- Les énumérations peuvent implémenter des interfaces afin d'associer un comportement à chaque constante
Questions Fréquemment Posées
La leçon « Définir et utiliser des énumérations » est-elle gratuite ?
Oui — le texte complet de « Définir et utiliser des énumérations » 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 « Définir et utiliser des énumérations » ?
Déclarez des types enum, utilisez leurs constantes et parcourez-les avec values() et ordinal(). 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 1 sur 4.
Combien de temps prend la leçon « Définir et utiliser des énumérations » ?
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
- Définir et utiliser des énumérations
- Énumérations avec champs et méthodes
- Expressions switch avec des énumérations
- EnumSet et EnumMap