Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Corps de classe propre à une constante d’énumération

En Java SE 21, une constante d’énumération peut passer des arguments au constructeur et définir son comportement dans son propre corps de classe.

Version : Java SE 21

Syntaxe

EnumConstant ::= Annotation* Identifier [ '(' [ ArgumentList ] ')' ] [ ClassBody ]
ArgumentList ::= Expression ( ',' Expression )*

Here [ ... ] means optional, * means zero or more, and quoted punctuation is literal. ClassBody is the constant's { ... } body.

Dans RED(30) { ... }, les parenthèses contiennent les arguments du constructeur et les accolades délimitent le corps de classe propre à la constante. Ce corps facultatif déclare implicitement une sous-classe anonyme, directe et final de Signal. On ne peut y déclarer ni constructeurs ni méthodes abstract.

Les constantes sont séparées par des virgules. Si d’autres déclarations suivent la liste dans le corps de l’enum, un point-virgule ; les sépare de la liste. Lors de l’initialisation de la classe, les arguments de chaque constante sont transmis au constructeur choisi selon les règles habituelles de résolution de surcharge. Sans parenthèses, la liste d’arguments est vide. Un constructeur d’énumération sans modificateur d’accès est private. Ici, Signal(int seconds) stocke l’argument dans le champ d’instance private final int seconds.

Si une énumération possède une méthode abstraite, elle doit avoir au moins une constante, et chaque constante doit fournir une implémentation concrète de la méthode dans son propre corps. Une implémentation manquante provoque une erreur de compilation. @Override permet au compilateur de vérifier que la méthode redéfinit bien une autre méthode. signal.next() sélectionne l’implémentation de la constante désignée par signal. Une méthode d’instance déclarée dans le corps d’une constante n’est appelable depuis l’extérieur de l’énumération que si elle redéfinit une méthode accessible de celle-ci.

Exemples

public class Main {
    enum Signal {
        RED(30) {
            @Override
            Signal next() { return GREEN; }
        },
        GREEN(25) {
            @Override
            Signal next() { return YELLOW; }
        },
        YELLOW(5) {
            @Override
            Signal next() { return RED; }
        };

        private final int seconds;

        private Signal(int seconds) {
            this.seconds = seconds;
        }

        int seconds() {
            return seconds;
        }

        abstract Signal next();
    }

    public static void main(String[] args) {
        for (Signal signal : Signal.values()) {
            System.out.println(signal.name() + " (" + signal.seconds()
                    + " s) -> " + signal.next().name());
        }
    }
}

Résultat

RED (30 s) -> GREEN
GREEN (25 s) -> YELLOW
YELLOW (5 s) -> RED

`seconds()` renvoie la durée mémorisée pour le signal courant, tandis que `next()` renvoie la constante suivante, qui existe déjà. `Signal.values()` renvoie les constantes dans l’ordre de déclaration.

Leçons associées

  • Java · Leçon 9 · Intermédiaire · Version : 2

Sources