WissensdatenbankPrüfungszentrum
DEDeutsch
Sprache wählen13

CKTIS / Java

Konstantenspezifischer Klassenrumpf in einem Enum

In Java SE 21 kann eine `enum`-Konstante Argumente an den Enum-Konstruktor übergeben und ihr Verhalten in einem eigenen Klassenrumpf definieren.

Version: 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) { ... } stehen die Konstruktorargumente in runden Klammern. Die geschweiften Klammern umschließen den Klassenrumpf dieser Konstante. Dieser optionale Rumpf deklariert implizit eine anonyme, direkte final-Unterklasse von Signal. Darin dürfen weder Konstruktoren noch abstract-Methoden deklariert werden.

Konstanten werden durch Kommas getrennt. Folgen im enum-Rumpf weitere Deklarationen, trennt ein Semikolon ; sie von der Konstantenliste. Bei der Klasseninitialisierung werden die Argumente jeder Konstante an den Enum-Konstruktor übergeben, den die üblichen Regeln zur Auflösung von Überladungen auswählen. Ohne runde Klammern gilt die Argumentliste als leer. Ein Enum-Konstruktor ohne Zugriffsmodifikator ist private. Hier speichert Signal(int seconds) das Argument im Instanzfeld private final int seconds.

Hat ein Enum eine abstrakte Methode, muss es mindestens eine Konstante geben, und jede Konstante muss die Methode in ihrem eigenen Rumpf konkret implementieren. Fehlt eine Implementierung, meldet der Compiler einen Fehler. Mit @Override prüft der Compiler, ob die Methode tatsächlich eine andere Methode überschreibt. signal.next() ruft die Implementierung der Konstante auf, auf die signal verweist. Eine im Rumpf einer Konstante deklarierte Instanzmethode kann von außerhalb der umgebenden Enum-Klasse nur aufgerufen werden, wenn sie eine zugängliche Methode dieser Klasse überschreibt.

Beispiele

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

Ergebnis

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

`seconds()` gibt die gespeicherte Dauer des aktuellen Signals zurück, `next()` die nächste bereits vorhandene Konstante. `Signal.values()` liefert die Konstanten in Deklarationsreihenfolge.

Zugehörige Lektionen

  • Java · Lektion 9 · Mittlere Stufe · Version: 2

Quellen