Méthodes abstraites dans les énumérations
Un comportement par constante
Méthodes abstraites dans les énumérations 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.
Comportement propre à chaque constante
Il arrive que chaque constante d'une énumération nécessite un comportement différent, et pas seulement des données différentes.
Java vous permet de déclarer une méthode abstraite dans l'énumération et de la redéfinir pour chaque constante. C'est le modèle des corps de méthode propres aux constantes.
public class Main {
enum Operation {
PLUS { public int apply(int a, int b) { return a + b; } },
MINUS { public int apply(int a, int b) { return a - b; } };
public abstract int apply(int a, int b);
}
public static void main(String[] args) {
System.out.println(Operation.PLUS.apply(3, 4));
System.out.println(Operation.MINUS.apply(10, 6));
}
}Fonctionnement
Chaque constante qui possède un corps devient une sous-classe anonyme de l'énumération.
La méthode abstraite oblige chaque constante à fournir une implémentation ; le compilateur garantit ainsi l'exhaustivité.
public class Main {
enum Operation {
TIMES { public int apply(int a, int b) { return a * b; } };
public abstract int apply(int a, int b);
}
public static void main(String[] args) {
// The constant is an instance of a generated subclass
System.out.println(Operation.TIMES.getClass().getSimpleName().isEmpty()
? "anonymous subclass" : Operation.TIMES.apply(6, 7));
}
}Une calculatrice complète
Les quatre opérations arithmétiques sont représentées par des constantes, chacune définissant son propre comportement apply.
public class Main {
enum Operation {
PLUS { public double apply(double a, double b) { return a + b; } },
MINUS { public double apply(double a, double b) { return a - b; } },
TIMES { public double apply(double a, double b) { return a * b; } },
DIVIDE{ public double apply(double a, double b) { return a / b; } };
public abstract double apply(double a, double b);
}
public static void main(String[] args) {
double x = 6, y = 3;
for (Operation op : Operation.values()) {
System.out.printf("%s -> %.1f%n", op, op.apply(x, y));
}
}
}Associer champs et comportement
Vous pouvez associer un champ, comme un symbole, à un comportement propre à chaque constante. Le champ identifie l'opération ; la méthode l'exécute.
public class Main {
enum Operation {
PLUS("+") { public double apply(double a, double b) { return a + b; } },
MINUS("-") { public double apply(double a, double b) { return a - b; } };
private final String symbol;
Operation(String symbol) { this.symbol = symbol; }
public abstract double apply(double a, double b);
@Override public String toString() { return symbol; }
}
public static void main(String[] args) {
Operation op = Operation.PLUS;
System.out.println("2 " + op + " 3 = " + op.apply(2, 3));
}
}Pourquoi pas une structure de sélection ?
Vous pourriez implémenter apply avec une seule structure de sélection selon la constante, mais l'approche fondée sur une méthode abstraite est plus sûre.
Si vous ajoutez une constante ultérieurement, le compilateur vous oblige à fournir son corps. Une structure de sélection pourrait ignorer silencieusement le nouveau cas.
public class Main {
enum Op {
SQUARE { public int apply(int n) { return n * n; } },
CUBE { public int apply(int n) { return n * n * n; } };
public abstract int apply(int n);
}
public static void main(String[] args) {
System.out.println(Op.SQUARE.apply(5));
System.out.println(Op.CUBE.apply(3));
}
}Méthodes concrètes et abstraites
Une énumération peut combiner des méthodes abstraites et concrètes. La logique partagée va dans une méthode concrète ; la logique variable reste abstraite.
public class Main {
enum Shape {
CIRCLE { public double area(double x) { return Math.PI * x * x; } },
SQUARE { public double area(double x) { return x * x; } };
public abstract double area(double x);
public String report(double x) { return this + " area = " + area(x); }
}
public static void main(String[] args) {
System.out.println(Shape.CIRCLE.report(2));
}
}Énumérations de stratégie
Une variante consiste à utiliser l'énumération de stratégie : les constantes délèguent leur traitement à une énumération de stratégie imbriquée au lieu de le redéfinir directement.
C'est utile lorsque plusieurs constantes partagent le même comportement. Ici, les jours de semaine et les week-ends diffèrent dans le calcul de la rémunération.
public class Main {
enum PayType {
WEEKDAY { int overtime(int mins) { return mins; } },
WEEKEND { int overtime(int mins) { return mins * 2; } };
abstract int overtime(int mins);
int pay(int mins) { return mins + overtime(Math.max(0, mins - 480)); }
}
public static void main(String[] args) {
System.out.println("Weekend pay: " + PayType.WEEKEND.pay(540));
}
}Énumération avec interface et corps spécifiques
Associez une interface à des corps propres aux constantes pour obtenir un polymorphisme maximal.
public class Main {
interface Command { String run(); }
enum Action implements Command {
START { public String run() { return "starting..."; } },
STOP { public String run() { return "stopping..."; } };
}
public static void main(String[] args) {
for (Action a : Action.values()) System.out.println(a.run());
}
}Accéder aux champs depuis les corps
Un corps propre à une constante peut lire les champs de cette constante, car chaque corps s'exécute dans le contexte de cette instance.
public class Main {
enum Tax {
STANDARD(0.20) { double apply(double amt) { return amt * (1 + rate); } },
REDUCED(0.05) { double apply(double amt) { return amt * (1 + rate); } };
protected final double rate;
Tax(double rate) { this.rate = rate; }
abstract double apply(double amt);
}
public static void main(String[] args) {
System.out.printf("%.2f%n", Tax.STANDARD.apply(100));
}
}Valeur par défaut puis redéfinition
Vous pouvez fournir une implémentation concrète par défaut dans le corps de l'énumération et ne la redéfinir que pour les constantes qui se comportent différemment.
public class Main {
enum Notifier {
EMAIL,
SMS { String send(String m) { return "SMS: " + m; } };
String send(String m) { return "EMAIL: " + m; }
}
public static void main(String[] args) {
System.out.println(Notifier.EMAIL.send("hi"));
System.out.println(Notifier.SMS.send("hi"));
}
}Une petite machine à états
Le comportement propre à chaque constante est particulièrement adapté aux machines à états : chaque état connaît sa propre transition.
public class Main {
enum State {
IDLE { State next() { return RUNNING; } },
RUNNING { State next() { return DONE; } },
DONE { State next() { return DONE; } };
abstract State next();
}
public static void main(String[] args) {
State s = State.IDLE;
for (int i = 0; i < 3; i++) { System.out.println(s); s = s.next(); }
System.out.println(s);
}
}Vérification rapide
Vérifiez votre compréhension des méthodes abstraites d'énumération.
Récapitulatif
Vous avez découvert le comportement propre à chaque constante :
- Déclarez une méthode abstraite et redéfinissez-la dans le corps de chaque constante.
- Chaque constante devient une sous-classe anonyme.
- Le compilateur impose l'exhaustivité, ce qui est plus fiable qu'une structure de sélection.
- Combinez champs, valeurs concrètes par défaut et interfaces pour créer des énumérations riches.
Ensuite, découvrez EnumSet, l'ensemble d'énumérations hautes performances.
public class Main {
enum E { A { int v() { return 1; } }; abstract int v(); }
public static void main(String[] args) {
System.out.println("Abstract enum recap: " + E.A.v());
}
}Questions Fréquemment Posées
La leçon « Méthodes abstraites dans les énumérations » est-elle gratuite ?
Oui — le texte complet de « Méthodes abstraites dans les é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 « Méthodes abstraites dans les énumérations » ?
Un comportement par constante 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 « Méthodes abstraites dans les é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
- Énumérations avec champs et méthodes
- Méthodes abstraites dans les énumérations
- EnumSet
- EnumMap