Énumérations avec champs et méthodes
Ajoutez des champs, des constructeurs et des méthodes aux énumérations pour encapsuler leur comportement.
Énumérations avec champs et méthodes 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.
Énumérations avec champs et méthodes
Les constantes d'énumération peuvent contenir des données. Ajoutez des champs en les déclarant ainsi qu'un constructeur. Le constructeur est automatiquement privé.
Déclarer des champs dans les énumérations
Chaque constante d'énumération appelle le constructeur lors du chargement de la classe. Les valeurs des champs sont définies une seule fois et sont immuables (lorsqu'ils sont déclarés final).
enum Planet {
MERCURY(3.303e+23, 2.4397e6),
VENUS (4.869e+24, 6.0518e6),
EARTH (5.976e+24, 6.37814e6),
MARS (6.421e+23, 3.3972e6);
private final double mass; // kilograms
private final double radius; // meters
Planet(double mass, double radius) {
this.mass = mass;
this.radius = radius;
}
public double mass() { return mass; }
public double radius() { return radius; }
}Ajouter des méthodes aux énumérations
Les types énumérés peuvent contenir toutes les méthodes que vous placeriez dans une classe, y compris des propriétés calculées.
enum Planet {
EARTH(5.976e+24, 6.37814e6);
// ... constructor and fields ...
static final double G = 6.67300E-11;
public double surfaceGravity() {
return G * mass / (radius * radius);
}
public double surfaceWeight(double otherMass) {
return otherMass * surfaceGravity();
}
}
double earthWeight = 75.0;
double mass = earthWeight / Planet.EARTH.surfaceGravity();
for (Planet p : Planet.values())
System.out.printf("Weight on %s: %.2f%n", p, p.surfaceWeight(mass));Méthodes abstraites des constantes d'énumération
Chaque constante peut fournir sa propre implémentation d'une méthode abstraite déclarée dans le corps de l'énumération.
enum Operation {
PLUS { public double apply(double x, double y) { return x + y; } },
MINUS { public double apply(double x, double y) { return x - y; } },
TIMES { public double apply(double x, double y) { return x * y; } },
DIVIDE{ public double apply(double x, double y) { return x / y; } };
public abstract double apply(double x, double y);
}
System.out.println(Operation.PLUS.apply(3, 4)); // 7.0
System.out.println(Operation.TIMES.apply(3, 4)); // 12.0Énumérations avec libellés textuels
Un modèle courant consiste à attribuer à chaque constante un libellé lisible par l'utilisateur, stocké dans un champ.
enum UserRole {
GUEST("Guest User"),
MEMBER("Registered Member"),
ADMIN("Administrator"),
SUPERADMIN("Super Administrator");
private final String label;
UserRole(String label) { this.label = label; }
public String label() { return label; }
public static UserRole fromLabel(String lbl) {
for (UserRole r : values())
if (r.label.equalsIgnoreCase(lbl)) return r;
throw new IllegalArgumentException(lbl);
}
}
System.out.println(UserRole.ADMIN.label()); // AdministratorÉnumération avec plusieurs champs
Les énumérations peuvent avoir autant de champs que nécessaire. Ici, une énumération de devises stocke à la fois le code ISO et le symbole.
enum Currency {
USD("US Dollar", "$"),
EUR("Euro", "\u20ac"),
GBP("British Pound", "\u00a3"),
JPY("Japanese Yen", "\u00a5");
public final String name;
public final String symbol;
Currency(String name, String symbol) {
this.name = name;
this.symbol = symbol;
}
public String format(double amount) {
return String.format("%s%.2f", symbol, amount);
}
}
System.out.println(Currency.EUR.format(99.99)); // \u20ac99.99Redéfinir toString()
Redéfinissez toString() dans une énumération pour renvoyer une représentation textuelle personnalisée au lieu du nom de la constante.
enum HttpMethod {
GET, POST, PUT, PATCH, DELETE;
@Override
public String toString() {
return name().toUpperCase();
}
public boolean hasBody() {
return this == POST || this == PUT || this == PATCH;
}
}
HttpMethod m = HttpMethod.POST;
System.out.println(m); // POST
System.out.println(m.hasBody()); // true
System.out.println(HttpMethod.GET.hasBody()); // falseÉnumération avec validation
Les constructeurs d'énumération peuvent valider leurs arguments afin d'empêcher les états non valides.
enum DiscountTier {
BRONZE(5), SILVER(10), GOLD(20), PLATINUM(30);
public final int percentage;
DiscountTier(int percentage) {
if (percentage < 0 || percentage > 100)
throw new IllegalArgumentException("Invalid: " + percentage);
this.percentage = percentage;
}
public double apply(double price) {
return price * (1 - percentage / 100.0);
}
}
System.out.println(DiscountTier.GOLD.apply(100.0)); // 80.0Motif du singleton avec une énumération
Une énumération à constante unique est le moyen le plus sûr d'implémenter un singleton en Java : elle est compatible avec la sérialisation et sûre pour les threads par défaut.
enum AppConfig {
INSTANCE;
private String dbUrl = "jdbc:postgresql://localhost/mydb";
private int maxConnections = 20;
public String getDbUrl() { return dbUrl; }
public int getMaxConnections() { return maxConnections; }
public void setDbUrl(String url) { this.dbUrl = url; }
}
// Access the singleton
AppConfig config = AppConfig.INSTANCE;
System.out.println(config.getDbUrl());Énumérations dans les modèles métier
Les énumérations sont très utilisées dans les modèles métier pour représenter des catégories sûres du point de vue des types : état d'une commande, mode de paiement, type de notification, etc.
enum PaymentMethod {
CREDIT_CARD("Credit Card", true),
DEBIT_CARD("Debit Card", true),
PAYPAL("PayPal", false),
CRYPTO("Cryptocurrency", false),
BANK_TRANSFER("Bank Transfer", false);
public final String displayName;
public final boolean instantCharge;
PaymentMethod(String displayName, boolean instantCharge) {
this.displayName = displayName;
this.instantCharge = instantCharge;
}
}Champ d'énumération ou valeur calculée
Les champs stockent des données fixes ; les méthodes calculent des valeurs dynamiques. Utilisez les champs pour les données constantes et les méthodes pour les valeurs dérivées.
enum DayType {
MONDAY(false), TUESDAY(false), WEDNESDAY(false),
THURSDAY(false), FRIDAY(false),
SATURDAY(true), SUNDAY(true);
private final boolean weekend;
DayType(boolean weekend) { this.weekend = weekend; }
public boolean isWeekend() { return weekend; }
public boolean isWeekday() { return !weekend; }
public static long weekdayCount() {
return java.util.Arrays.stream(values())
.filter(DayType::isWeekday).count();
}
}
System.out.println(DayType.weekdayCount()); // 5Vérification rapide
En quoi le constructeur d'une énumération diffère-t-il de celui d'une classe ordinaire ?
Récapitulatif : énumérations avec champs et méthodes
Points essentiels :
- Ajoutez des champs et un constructeur pour associer des données à chaque constante
- Les constructeurs d'énumération sont implicitement privés
- Les méthodes abstraites permettent à chaque constante de fournir sa propre implémentation
- Redéfinissez toString() pour personnaliser les noms affichés
- Les énumérations à constante unique constituent la meilleure implémentation d'un singleton
- Les énumérations s'intègrent naturellement aux modèles métier comme catégories sûres du point de vue des types
Questions Fréquemment Posées
La leçon « Énumérations avec champs et méthodes » est-elle gratuite ?
Oui — le texte complet de « Énumérations avec champs et méthodes » 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 « Énumérations avec champs et méthodes » ?
Ajoutez des champs, des constructeurs et des méthodes aux énumérations pour encapsuler leur comportement. 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 « Énumérations avec champs et méthodes » ?
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