Énumérations avec champs et méthodes
Ajoutez un comportement aux énumérations
Énumérations avec champs et méthodes 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.
Les énumérations sont des classes à part entière
Une enum Java est bien plus qu’une liste de constantes. C’est une véritable classe dont les instances sont les constantes.
Les énumérations peuvent donc avoir des champs, des constructeurs et des méthodes, comme n’importe quelle autre classe.
public class Main {
enum Direction { NORTH, SOUTH, EAST, WEST }
public static void main(String[] args) {
Direction d = Direction.NORTH;
System.out.println(d + " is a " + d.getClass().getSuperclass().getSimpleName());
}
}Ajouter un champ
Vous pouvez associer des données à chaque constante. Déclarez un champ final et un constructeur, puis transmettez les valeurs entre parenthèses après chaque constante.
public class Main {
enum Planet {
EARTH(9.81), MARS(3.71), JUPITER(24.79);
private final double gravity;
Planet(double gravity) { this.gravity = gravity; }
double gravity() { return gravity; }
}
public static void main(String[] args) {
System.out.println("Mars gravity: " + Planet.MARS.gravity());
}
}Le constructeur d’une énumération est privé
Les constructeurs d’énumération sont implicitement privés. Vous ne pouvez pas appeler new sur une énumération ; le JVM crée les constantes une seule fois lors du chargement de la classe.
Cela garantit un ensemble fixe et fini d’instances.
public class Main {
enum Coin {
PENNY(1), NICKEL(5), DIME(10), QUARTER(25);
private final int cents;
Coin(int cents) { this.cents = cents; }
int cents() { return cents; }
}
public static void main(String[] args) {
int total = Coin.QUARTER.cents() + Coin.DIME.cents();
System.out.println("Total cents: " + total);
}
}Plusieurs champs
Une constante peut contenir plusieurs données. Ici, chaque planète stocke à la fois sa masse et son rayon.
public class Main {
enum Planet {
EARTH(5.976e24, 6.37814e6),
MARS(6.421e23, 3.3972e6);
private final double mass, radius;
Planet(double mass, double radius) { this.mass = mass; this.radius = radius; }
double surfaceGravity() {
final double G = 6.67300E-11;
return G * mass / (radius * radius);
}
}
public static void main(String[] args) {
System.out.printf("Earth g = %.2f%n", Planet.EARTH.surfaceGravity());
}
}Méthodes d’instance
Les méthodes d’une énumération peuvent calculer des résultats à partir des propres champs de la constante, comme des méthodes d’instance ordinaires.
public class Main {
enum Size {
SMALL(8), MEDIUM(12), LARGE(16);
private final int ounces;
Size(int ounces) { this.ounces = ounces; }
int ounces() { return ounces; }
double liters() { return ounces * 0.0295735; }
}
public static void main(String[] args) {
System.out.printf("Large = %.2f L%n", Size.LARGE.liters());
}
}Nom intégré et ordinal
Chaque énumération reçoit name() (l'identifiant exact) et ordinal() (sa position indexée à partir de zéro).
Préférez stocker vos propres données plutôt que de vous appuyer sur ordinal(), qui devient incorrect si vous réorganisez les constantes.
public class Main {
enum Day { MON, TUE, WED }
public static void main(String[] args) {
for (Day d : Day.values()) {
System.out.println(d.name() + " -> ordinal " + d.ordinal());
}
}
}values et valueOf
Le compilateur génère deux méthodes utilitaires statiques :
values()renvoie un tableau contenant toutes les constantes.valueOf(String)recherche une constante par son nom et lance une exception si elle est introuvable.
public class Main {
enum Status { ACTIVE, PAUSED, CLOSED }
public static void main(String[] args) {
System.out.println("count: " + Status.values().length);
Status s = Status.valueOf("PAUSED");
System.out.println("parsed: " + s);
}
}Redéfinition de toString
Vous pouvez redéfinir toString() pour fournir des libellés plus conviviaux tout en conservant le nom de la constante pour le code.
public class Main {
enum Priority {
LOW, MEDIUM, HIGH;
@Override public String toString() {
return name().charAt(0) + name().substring(1).toLowerCase();
}
}
public static void main(String[] args) {
for (Priority p : Priority.values()) System.out.println(p);
}
}Énumérations dans une structure de sélection
Les énumérations s'utilisent naturellement dans les structures de sélection. Les expressions modernes de sélection vérifient l'exhaustivité et évitent le passage automatique au cas suivant.
public class Main {
enum Traffic { RED, YELLOW, GREEN }
static String action(Traffic t) {
return switch (t) {
case RED -> "Stop";
case YELLOW -> "Slow down";
case GREEN -> "Go";
};
}
public static void main(String[] args) {
System.out.println(action(Traffic.GREEN));
}
}Structures Map de recherche statiques
Une pratique courante consiste à créer une Map statique qui associe un champ à la constante correspondante, puis à la construire une seule fois dans un initialiseur statique.
import java.util.HashMap;
import java.util.Map;
public class Main {
enum Op {
PLUS("+"), MINUS("-");
private final String symbol;
Op(String symbol) { this.symbol = symbol; }
private static final Map<String, Op> BY_SYMBOL = new HashMap<>();
static { for (Op o : values()) BY_SYMBOL.put(o.symbol, o); }
static Op fromSymbol(String s) { return BY_SYMBOL.get(s); }
}
public static void main(String[] args) {
System.out.println(Op.fromSymbol("-"));
}
}Les énumérations implémentent des interfaces
Une énumération peut implémenter une interface, ce qui permet aux constantes de s'intégrer à du code polyvalent.
public class Main {
interface Describable { String describe(); }
enum Animal implements Describable {
DOG, CAT;
public String describe() { return "A " + name().toLowerCase(); }
}
public static void main(String[] args) {
Describable d = Animal.DOG;
System.out.println(d.describe());
}
}Vérification rapide
Vérifiez votre compréhension des champs d'énumération.
Récapitulatif
Vous avez appris que les énumérations sont des classes à part entière :
- Les constantes peuvent contenir des champs définis par l'intermédiaire d'un constructeur privé.
- Les énumérations peuvent posséder des méthodes d'instance et redéfinir
toString(). values()etvalueOf()sont générées pour vous.- Les énumérations peuvent implémenter des interfaces et privilégient les champs à
ordinal().
Ensuite, le comportement propre à chaque constante avec des méthodes abstraites.
public class Main {
enum Greeting { HELLO; String text() { return "Hi"; } }
public static void main(String[] args) {
System.out.println("Enum fields recap: " + Greeting.HELLO.text());
}
}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 un comportement aux énumérations 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 « É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
- Énumérations avec champs et méthodes
- Méthodes abstraites dans les énumérations
- EnumSet
- EnumMap