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