Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Corpo di classe specifico di una costante enum

In Java SE 21, una costante di un `enum` può passare argomenti al costruttore e definire il proprio comportamento in un corpo di classe dedicato.

Versione: Java SE 21

Sintassi

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.

In RED(30) { ... }, le parentesi tonde racchiudono gli argomenti del costruttore e le graffe delimitano il corpo di classe della costante. Questo corpo facoltativo dichiara implicitamente una sottoclasse anonima, diretta e final di Signal. Non può dichiarare costruttori né metodi abstract.

Le costanti si separano con virgole. Se dopo l’elenco ci sono altre dichiarazioni nel corpo dell’enum, un punto e virgola ; le separa dall’elenco. Durante l’inizializzazione della classe, gli argomenti di ogni costante vengono passati al costruttore selezionato secondo le normali regole di risoluzione dell’overload. Omettere le parentesi equivale a usare un elenco di argomenti vuoto. Un costruttore di un enum senza modificatore di accesso è private. Qui Signal(int seconds) memorizza l’argomento nel campo di istanza private final int seconds.

Se un enum ha un metodo astratto, deve avere almeno una costante e ogni costante deve fornire nel proprio corpo un’implementazione concreta del metodo. Un’implementazione mancante causa un errore di compilazione. @Override consente al compilatore di verificare che il metodo ne ridefinisca effettivamente un altro. signal.next() seleziona l’implementazione della costante a cui fa riferimento signal. Un metodo di istanza dichiarato nel corpo di una costante è invocabile dall’esterno dell’enum che la contiene solo se ridefinisce un metodo accessibile di tale enum.

Esempi

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());
        }
    }
}

Risultato

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

`seconds()` restituisce la durata memorizzata per il segnale corrente, mentre `next()` restituisce la costante successiva, già esistente. `Signal.values()` restituisce le costanti nell’ordine di dichiarazione.

Lezioni correlate

  • Java · Lezione 9 · Intermedio · Versione: 2

Fonti