CKTIS / Java
Eigen class body van een enumconstante
In Java SE 21 kan een `enum`-constante argumenten aan de constructor doorgeven en haar gedrag in een eigen class body vastleggen.
Versie: Java SE 21
Syntax
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) { ... } staan de constructorargumenten tussen ronde haakjes en staat de class body van de constante tussen accolades. Die optionele body declareert impliciet een anonieme, directe final-subklasse van Signal. Je mag er geen constructors of abstract-methoden in declareren.
Scheid constanten met komma’s. Als er na de lijst nog declaraties in de body van de enum volgen, scheidt een puntkomma ; die declaraties van de lijst. Bij de initialisatie van de klasse gaan de argumenten van elke constante naar de enumconstructor die volgens de gewone regels voor overloadselectie wordt gekozen. Zonder ronde haakjes is de argumentenlijst leeg. Een enumconstructor zonder toegangsmodifier is private. Hier slaat Signal(int seconds) het argument op in het instantieveld private final int seconds.
Als een enum een abstracte methode heeft, moet die enum minstens één constante hebben en moet elke constante in haar eigen body een concrete implementatie bieden. Een ontbrekende implementatie levert een compileerfout op. Met @Override controleert de compiler of de methode echt een andere methode overschrijft. signal.next() kiest de implementatie van de constante waarnaar signal verwijst. Een instantiemethode die in de body van een constante is gedeclareerd, kun je alleen van buiten de omringende enumklasse aanroepen als die methode een toegankelijke methode van die enum overschrijft.
Voorbeelden
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());
}
}
}Resultaat
RED (30 s) -> GREEN GREEN (25 s) -> YELLOW YELLOW (5 s) -> RED
`seconds()` geeft de opgeslagen duur voor het huidige signaal terug, terwijl `next()` de volgende, al bestaande constante teruggeeft. `Signal.values()` geeft de constanten in declaratievolgorde terug.
Gerelateerde lessen
- Java · Les 9 · Gemiddeld · Versie: 2