Enum-Entwurfsmuster

Enum-Entwurfsmuster

0:00 Enums kennen Sie. Fast jeder Java-Entwickler hat schon eine Aufzählung geschrieben, und die Syntax ist in einer Minute erklärt. Genau das ist das Problem: Weil der Einstieg so einfach ist, bleiben viele bei der einfachen Verwendung stehen und übersehen, dass ein Enum eine vollwertige Klasse ist — mit Feldern, Konstruktor, Methoden, sogar mit abstrakten Methoden.

0:20 In diesem Modul geht es um genau diese Möglichkeiten. Wir schauen uns eine Handvoll Entwurfsmuster an, die Ihnen in echten Projekten immer wieder begegnen und die oft den Unterschied machen zwischen Code, der die Fachlichkeit trägt, und Code, der sie nur andeutet.

Enum-Entwurfsmuster

0:35 Der zweite Tag beginnt mit dem zweiten Summentyp aus dem gestrigen Modul. Wir klären zunächst, was ein Enum eigentlich ist — die Antwort überrascht manche. Dann binden wir zusätzliche Daten an die Konstanten und finden den Weg wieder zurück, wenn Werte von außen hereinkommen. Danach geht es um Verhalten: Es gibt vier verschiedene Wege, jeder Konstante eigenes Verhalten mitzugeben, und die Wahl dazwischen ist eine Entwurfsentscheidung.

0:59 Zum Schluss schauen wir uns zwei Sammlungen an, die eigens für Enums gebaut wurden und die viele gar nicht kennen. Vier Themen strukturieren das Modul. Der erste Punkt ist die Grundlage — solange Sie ein Enum für eine Namensliste halten, bleibt der Rest unzugänglich. Der zweite ist der praktisch häufigste Fall überhaupt: Ein Fremdsystem überträgt Kürzel oder Zahlencodes, und die müssen in beide Richtungen umgesetzt werden.

1:23 Der dritte betrifft Verhalten und ist die eigentliche Entwurfsfrage dieses Moduls. Und der vierte ist schnelles Wissen mit sofortigem Nutzen — zwei Sammlungen, die fast immer die bessere Wahl sind und dennoch selten verwendet werden.

Enums verstehen

1:36 Beginnen wir mit einer Frage, die banal klingt: Was ist ein Enum eigentlich? Die meisten Antworten lauten „eine Liste von Konstanten", und das ist auch nicht falsch. Es ist nur unvollständig — und diese Unvollständigkeit verstellt den Blick auf alles, was in diesem Modul noch kommt. Die genauere Antwort ist ein einziger Satz, aber sie öffnet die Tür zu den Feldern, den Konstruktoren und den Methoden, mit denen wir gleich arbeiten werden.

2:01 Nehmen wir uns also einen Moment für diese Grundlage. Ein Enum ist eine besondere Klassenart mit einer festen Menge an Instanzen. Das ist der entscheidende Satz. Jede Konstante ist kein Name, sondern ein Objekt — eine Instanz dieses Typs, und zwar genau eine. Damit erbt ein Enum implizit von java.lang.Enum und bringt einiges mit: eine natürliche Reihenfolge in Deklarationsreihenfolge, die Methoden values, name und valueOf.

2:28 Wenn Sie sich merken wollen, warum das wichtig ist: Weil ein Enum eine Klasse ist, dürfen Sie alles damit tun, was Sie mit Klassen tun — und genau darauf bauen die Muster in diesem Modul auf. Hier die schlichte Form, wie sie fast überall zu finden ist — drei Konstanten, mehr nicht. Interessant sind die beiden Zeilen darunter.

2:48 valueOf sucht eine Konstante über ihren exakten Namen; merken Sie sich das Wort „exakt", darauf kommen wir zurück. Und dann der Vergleich mit dem doppelten Gleichheitszeichen. Das ist hier ausdrücklich korrekt und nicht etwa Schlamperei. Weil pro Konstante genau eine Instanz existiert, vergleicht der Identitätsvergleich das Richtige.

3:09 equals wäre nicht falsch, aber überflüssig — und hätte den Nachteil, dass Sie zusätzlich auf null prüfen müssten. Jetzt die Entwurfsfrage dahinter. Ein int erlaubt Milliarden Werte, von denen in Ihrem Fall vielleicht fünf gültig sind. Jede Stelle im Code, die so einen Wert entgegennimmt, muss also entweder prüfen oder hoffen — und geprüft wird selten überall.

3:31 Ein Enum dreht das um: Der ungültige Zustand wird unschreibbar. Das ist dieselbe Denkfigur wie gestern beim Modellieren, nur eine Ebene kleiner. Und es gibt einen angenehmen Nebeneffekt, den man nicht unterschätzen sollte: Die IDE kennt die möglichen Werte und schlägt sie vor. Das spart im Alltag mehr Zeit als jede Dokumentation.

3:52 Diese Übersicht zeigt, was Sie geschenkt bekommen, ohne eine Zeile zu schreiben. Der Punkt, auf den ich Sie besonders hinweisen möchte, steht in der vierten Zeile: ordinal. Diese Methode liefert die Position der Konstante in der Deklaration, und sie wirkt ungeheuer praktisch — man könnte sie ja in der Datenbank speichern. Tun Sie es nicht.

4:11 Sobald jemand die Konstanten umsortiert oder eine in der Mitte einfügt, ändern sich alle Zahlen, und zwar stillschweigend. Das ist einer der unangenehmsten Fehler überhaupt, weil er alte Daten falsch interpretiert, ohne irgendwo zu scheitern. Diese Aufgabe ist eine Suchaufgabe. Gehen Sie durch bestehenden Code und halten Sie Ausschau nach Sammlungen von Konstanten — typischerweise eine Reihe von static final String direkt untereinander.

4:36 Wo so etwas steht, wollte jemand ein Enum und hatte keines. Die Fähigkeit, die Sie üben, ist das Erkennen: Welches Feld hat in Wahrheit einen kleinen, festen Wertebereich? Der Erfolg zeigt sich daran, dass die frühere Prüfung ersatzlos entfällt — nicht ersetzt wird, sondern verschwindet, weil sie überflüssig geworden ist.

4:56 Den ersten Punkt haben wir eben besprochen — ordinal gehört nicht in die Persistenz. Der zweite ist harmlos, aber verbreitet: Enums mit equals vergleichen; das funktioniert, ist aber umständlicher und erzwingt zusätzliche Null-Prüfungen. Der dritte betrifft valueOf: Es wirft bei jedem Tippfehler eine Ausnahme, und mit Eingaben von außen sollte man es deshalb nicht füttern.

5:17 Dafür gibt es das Muster im dritten Kapitel. Und der vierte ist eine Entwurfsfrage — wenn sich die Menge im laufenden Betrieb ändern soll, ist es kein Enum, sondern eine Stammdatentabelle.

Werte an Konstanten binden

5:29 Kommen wir zum ersten und mit Abstand häufigsten Muster. In der Praxis reicht der bloße Name einer Konstante fast nie aus. Es gibt ein Kürzel für die Schnittstelle zum Nachbarsystem, einen Zahlencode für die Datenbank, einen Text für die Anzeige. Diese Zusatzinformationen müssen irgendwo stehen — und die Frage ist, wo. Sehr oft landen sie in einer separaten Umsetzungstabelle oder in einem switch irgendwo im Code.

5:54 Es geht besser, und der bessere Weg nutzt genau das aus, was wir eben über Enums festgestellt haben. Die Antwort nutzt genau das aus, was wir vorhin festgestellt haben: Ein Enum ist eine Klasse und darf Felder, einen Konstruktor und Methoden haben. Damit lässt sich der zusätzliche Wert direkt an die Konstante binden — etwa das Kürzel, mit dem ein Fremdsystem den Status überträgt.

6:17 Der Gewinn ist ein organisatorischer: Die Zuordnung steht an genau einer Stelle, nämlich dort, wo auch die Konstante steht. Keine zweite Datei, keine Umsetzungstabelle, die beim nächsten neuen Status vergessen wird. Und genau dieses Vergessen ist der Fehler, den dieses Muster verhindert. So sieht das aus. Hinter jeder Konstante steht in Klammern ihr Kürzel, und der Konstruktor unten nimmt es entgegen. Zwei Dinge sind erwähnenswert.

6:43 Erstens: Das Semikolon nach der letzten Konstante ist Pflicht — es trennt die Konstantenliste vom übrigen Klassenrumpf. Wer es vergisst, bekommt eine Fehlermeldung, die zunächst rätselhaft wirkt. Zweitens: Der Konstruktor ist implizit privat, und Sie können ihn auch nicht öffentlich machen. Das ist konsequent, denn die Instanzen sind ja bereits festgelegt. Ein Enum mit Konstruktor bleibt trotzdem ein Typ, den niemand von außen instanziieren kann.

7:11 Warum lohnt sich dieses Muster? Weil es Zusammengehörendes zusammenhält. Wenn Sie in einem halben Jahr einen vierten Status ergänzen, tragen Sie sein Kürzel in derselben Zeile ein — Sie können es gar nicht vergessen. Bei einer separaten Umsetzungstabelle passiert genau das dagegen regelmäßig. Ein zweiter Punkt ist die Threadsicherheit: Es gibt pro Konstante nur eine Instanz, die sich alle teilen.

7:34 Deshalb müssen die Felder final sein und dürfen keine veränderlichen Objekte enthalten. Das ist keine Formalie — ein veränderliches Feld in einem Enum ist ein globaler Zustand mit allen bekannten Nebenwirkungen. In dieser Aufgabe verlagern Sie eine Umsetzung, die bisher woanders stand, an ihren richtigen Ort. Der Erfolg ist daran erkennbar, dass ein switch verschwindet — und das ist ein Muster, das Ihnen in diesem Modul noch öfter begegnen wird.

8:01 Interessant wird die Zusatzaufgabe: Ergänzen Sie eine zweite Eigenschaft, etwa ob der Status noch änderbar ist, und prüfen Sie kritisch, ob sie wirklich zur Konstante gehört. Nicht alles, was man an ein Enum hängen kann, gehört auch dorthin. Diese Frage kommt im letzten Kapitel noch einmal auf. Der erste Punkt ist der gefährlichste: ein veränderliches Feld im Enum.

8:23 Weil sich alle Aufrufer dieselbe Instanz teilen, wirkt jede Änderung überall — das ist ein globaler Zustand durch die Hintertür. Der zweite ist das fehlende Semikolon, das wir eben angesprochen haben; ärgerlich, aber schnell behoben. Der dritte ist eine Erwartung, die Java nicht erfüllt: Der Konstruktor lässt sich nicht öffentlich machen.

8:42 Und der vierte ist ein schleichender Prozess — ein Enum, das Fachlogik anzieht, die mit den Konstanten selbst nichts zu tun hat, wird mit der Zeit zum Sammelbecken.

Das fromValue-Muster

8:53 Wir haben jetzt Werte an die Konstanten gebunden. Damit ist die eine Richtung gelöst: von der Konstante zum Kürzel. Aber Daten fließen ja in beide Richtungen — sie kommen auch herein, aus einer Schnittstelle, aus einer Datei, aus der Datenbank. Für diesen Rückweg gibt es ein etabliertes Muster mit einem eigenen Namen. Es ist schnell umgesetzt, und trotzdem steckt darin eine Entwurfsentscheidung, die oft nebenbei getroffen wird und später überall im Code spürbar ist.

9:20 Zunächst die Einschränkung, die viele überrascht: valueOf hilft hier nicht. Diese Methode sucht ausschließlich über den exakten Namen der Konstante, nicht über gebundene Werte. Für Kürzel oder Zahlencodes müssen Sie also selbst eine statische Suchmethode schreiben. Der Name ist Konvention und variiert von Projekt zu Projekt — fromValue, vonKuerzel, parse.

9:41 Wichtig ist weniger der Name als die Konsequenz: Legen Sie sich auf einen fest und halten Sie ihn im ganzen Projekt durch. Uneinheitliche Namen für dasselbe Muster kosten jeden Leser Zeit. Die einfachste Umsetzung ist genau das, was Sie erwarten: über alle Konstanten laufen und vergleichen. values liefert dafür ein Feld mit allen Konstanten.

10:02 Beachten Sie den Hinweis in der Fußzeile — values erzeugt bei jedem Aufruf ein frisches Feld, weil das zurückgegebene Array veränderlich wäre und die ursprüngliche Reihenfolge geschützt werden muss. Bei drei Konstanten und gelegentlichen Aufrufen ist das völlig egal. Bei fünfzig Konstanten in einer Schleife über zehntausend Datensätze ist es das nicht mehr.

10:22 Dann lohnt sich eine einmalig aufgebaute Map. Der rote Faden hier ist nicht die Implementierung — die ist trivial —, sondern Schritt zwei. Was passiert, wenn kein Treffer da ist? Das ist die eigentliche Entwurfsentscheidung, und sie wird oft nebenbei getroffen, ohne dass jemand darüber nachdenkt. Die übrigen Schritte sind Handwerk: Schlüssel festlegen, Datenmenge abschätzen, Namen vereinheitlichen.

10:45 Nehmen Sie sich für Schritt zwei bewusst einen Moment Zeit, denn diese Entscheidung wirkt sich auf jeden Aufrufer aus — und lässt sich später nur schwer ändern. Vier Möglichkeiten stehen zur Wahl, und die Tabelle nennt zu jeder den Preis. Die Ausnahme passt, wenn ungültige Daten ein echter Fehler sind — der Aufrufer muss sich dann darum kümmern, und das ist gut so. Optional passt, wenn das Fehlen normal ist.

10:55 Die dritte Zeile ist die verführerischste und deshalb die gefährlichste: Ein stiller Vorgabewert lässt das Programm weiterlaufen und versteckt Datenfehler oft monatelang. Wenn Sie diese Variante wählen, dann bitte bewusst und mit einer Protokollzeile. Und null ist praktisch nie die richtige Antwort — es verlagert nur die Prüfung an jeden einzelnen Aufrufer.

10:56 Diese Aufgabe hat zwei Teile. Der erste ist die Suchmethode selbst — schnell geschrieben. Der zweite ist wichtiger: Testen Sie ausdrücklich den unbekannten Fall. Genau dieser Test fehlt in der Praxis fast immer, und genau er dokumentiert Ihre Entscheidung von der vorigen Folie. Als Zusatz können Sie eine zweite Fassung mit vorbereiteter Map bauen und beide bei tausend Aufrufen vergleichen.

11:19 Das gibt Ihnen ein Gefühl dafür, ab wann sich der Aufwand lohnt — und ab wann er verfrühte Optimierung ist. Der erste Punkt ist der Leistungsfehler, den wir angesprochen haben — values in einer heißen Schleife. Der zweite kommt aus der Praxis mit Fremdsystemen: Groß- und Kleinschreibung ungeprüft zu übernehmen, funktioniert genau so lange, bis das andere System eine Zeile ändert.

11:41 Der dritte ist die null-Rückgabe, die die Arbeit nach außen verlagert. Und der vierte ist ein technisches Versehen mit spürbarer Wirkung: Wenn die Map nicht statisch ist, wird sie pro Objekt neu gefüllt — und damit ist der ganze Vorteil dahin.

Verhalten in Enums

11:55 Bis hierhin haben wir Daten an Konstanten gebunden — Kürzel, Codes, Texte. Jetzt gehen wir einen Schritt weiter und fragen: Kann eine Konstante auch eigenes Verhalten tragen? Sie kann, und zwar auf vier verschiedenen Wegen. Das klingt zunächst nach einem lästigen Auswahlproblem, ist aber eine nützliche Bandbreite — die vier Wege unterscheiden sich in Lesbarkeit, Umfang und darin, wie viel Sicherheit Sie beim Hinzufügen neuer Konstanten bekommen.

12:21 Schauen wir sie uns an und klären dann, wonach man auswählt. Die vier Wege sind: ein switch in einer gewöhnlichen Methode, eine abstrakte Methode mit einem eigenen Rumpf je Konstante, eine implementierte Schnittstelle, oder ein Feld vom Typ einer funktionalen Schnittstelle. Alle vier sind gültig, keiner ist grundsätzlich überlegen. Was ich Ihnen mitgeben möchte, ist die Auswahlfrage — und die hat weniger mit Geschmack zu tun, als man denkt.

12:46 Sie hängt an der Länge der Logik und daran, wie viel Sicherheit Sie beim Hinzufügen neuer Konstanten haben wollen. Sehen wir uns zwei davon im Code an. Das ist die polymorphe Variante, und sie hat eine schöne Eigenschaft: Die Umsetzung steht direkt an der Konstante. Wer ADDIEREN liest, sieht in derselben Zeile, was ADDIEREN tut.

13:06 Der zweite Vorteil ist der wichtigere: Die Methode ist abstrakt, also erzwingt der Compiler für jede neue Konstante eine Umsetzung. Sie können gar nicht vergessen, den neuen Fall zu behandeln. Der Preis dafür steht in der Fußzeile — bei vielen Konstanten wird das Enum lang, und die Klammern häufen sich. Bei drei bis fünf Konstanten mit je zwei Zeilen Logik ist diese Variante meist die beste.

13:29 Und hier dieselbe Fachlichkeit noch einmal, deutlich kompakter. Statt eines Methodenrumpfs steht hinter jeder Konstante ein Lambda-Ausdruck, der im Konstruktor in einem Feld landet. IntBinaryOperator stammt aus java.util.function und beschreibt genau das, was wir brauchen: zwei Zahlen rein, eine raus. Für andere Signaturen finden Sie dort passende Gegenstücke.

13:51 Der Reiz ist die Knappheit, und für Einzeiler ist das die schönste Lösung. Aber Vorsicht: Sobald die Logik über eine Zeile hinausgeht, kippt die Lesbarkeit — und dann ist die vorherige Variante wieder im Vorteil. Diese Gegenüberstellung ist Ihre Entscheidungshilfe. Der erste Weg, der switch, hat einen Nachteil, den man kennen sollte: Es gibt keine Prüfung auf Vollständigkeit, eine neue Konstante rutscht durch.

14:16 Der zweite erzwingt jede Umsetzung, kostet aber Zeilen. Der dritte lohnt sich, wenn Sie eine Vorgabe im Enum haben und nur einzelne Konstanten abweichen wollen — eine Möglichkeit, die gern übersehen wird. Der vierte ist der kompakteste. Die Faustregel, die ich Ihnen mitgeben möchte, steht in der Fußzeile: Länge der Logik entscheidet. Einzeiler als Lambda, alles Größere als abstrakte Methode.

14:41 Hier üben Sie den Umbau, der den switch verschwinden lässt. Der eigentliche Gewinn zeigt sich beim Erweitern: Sobald das Verhalten an der Konstante hängt, erzwingt eine neue Konstante auch eine neue Umsetzung. Machen Sie sich die Mühe, dieselbe Operation zweimal zu schreiben — einmal als abstrakte Methode, einmal als Lambda-Feld. Und entscheiden Sie danach.

15:01 Diese direkte Gegenüberstellung ist lehrreicher als jede Empfehlung, weil Sie dabei ein Gefühl für die Grenze zwischen kompakt und kryptisch entwickeln. Der erste Punkt ist der switch ohne Vollständigkeitsprüfung — er funktioniert, bis jemand eine Konstante ergänzt und die eine Stelle übersieht. Der zweite ist die überdehnte Lambda-Variante.

15:20 Der dritte ist ein echter Stolperstein, den man nur einmal erlebt: Im Konstruktor einer Konstante können Sie nicht auf andere Konstanten zugreifen — die sind zu diesem Zeitpunkt noch nicht fertig initialisiert. Die Fehlermeldung ist wenig hilfreich, die Ursache dafür umso klarer. Und der vierte ist eine Frage der Sichtbarkeit: Verhalten, das nur intern gebraucht wird, muss nicht öffentlich sein.

EnumSet und EnumMap

15:43 Zum Abschluss dieses Moduls zwei Klassen, die viele nicht kennen, obwohl es sie seit Java fünf gibt. Beide sind ausschließlich für Enums gebaut, beide sind ihren allgemeinen Gegenstücken in Speicherverbrauch und Geschwindigkeit deutlich überlegen — und beide werden viel zu selten verwendet. Der Grund dafür ist banal: HashMap und HashSet fallen einem zuerst ein, und sie funktionieren ja auch.

16:05 Es lohnt sich trotzdem, die Alternativen zu kennen, denn sie kosten nichts außer dem Wissen um ihre Existenz. EnumSet speichert eine Menge von Konstanten intern als Bitmuster. Stellen Sie sich eine Reihe von Kippschaltern vor — für jede Konstante einer. Das kostet kaum Speicher, und die Mengenoperationen sind entsprechend schnell.

16:25 EnumMap geht ähnlich vor: Sie nutzt die Position der Konstante als Feldindex, braucht also weder Hashwerte noch Kollisionsbehandlung. Beide setzen voraus, dass alle Elemente beziehungsweise Schlüssel zum selben Enum gehören — und genau diese Einschränkung erlaubt die effiziente Umsetzung. Man bezahlt Allgemeinheit mit Geschwindigkeit, hier andersherum.

16:46 Ein typischer Anwendungsfall: An welchen Tagen nimmt das Lager Ware an? Die Antwort ist eine Menge von Wochentagen, und dafür ist EnumSet gemacht. Die range-Methode nimmt einen zusammenhängenden Bereich in Deklarationsreihenfolge, was hier genau passt. Daneben gibt es of für einzelne Werte, noneOf für die leere Menge und complementOf für das Gegenstück. Im Alltag brauchen Sie meistens of.

17:09 Der eigentliche Punkt dieser Folie ist aber ein anderer: Immer wenn mehrere Zustände gleichzeitig gelten können — Schalter, Berechtigungen, Merkmale —, ist EnumSet das passende Werkzeug. Und hier der zweite Fall: eine Zuordnung, die bewusst außerhalb des Enums steht. Das mag zunächst wie ein Widerspruch zum zweiten Kapitel wirken, wo wir Werte an die Konstanten gebunden haben. Ist es aber nicht — es ist die Ergänzung dazu.

17:35 Anzeigetexte sind Sache der Oberfläche, nicht der Fachlichkeit. Wenn Sie sie ins Enum legen, binden Sie Ihre Fachschicht an die Sprache der Benutzeroberfläche, und spätestens bei der zweiten Sprache wird das unangenehm. Die EnumMap ist hier also nicht nur die schnellere, sondern auch die architektonisch sauberere Wahl. Fassen wir die Auswahl zusammen. EnumSet nehmen Sie, wenn mehrere Zustände gleichzeitig gelten können. EnumMap, wenn eine Zuordnung absichtlich außerhalb des Enums bleiben soll.

18:04 Beide brauchen den Enum-Typ beim Erzeugen — bei EnumMap als Klassenobjekt im Konstruktor, was beim ersten Mal überrascht. Und dann noch ein Hinweis, der Ihnen Suchzeit spart: Für Enums als Werte statt als Schlüssel gibt es kein optimiertes Gegenstück. Die Optimierung funktioniert nur über die Schlüsselseite, weil nur dort die feste Positionsnummer hilft.

18:25 Die eigentliche Übung hier ist nicht die Verwendung der Sammlungen, sondern die Entscheidung davor. Fragen Sie sich bei jeder Zuordnung, ob sie fachlich zur Konstante gehört. Gehört sie dazu — wie das Kürzel für die Schnittstelle —, dann ins Enum. Gehört sie zu einer bestimmten Sicht auf die Daten — wie der Anzeigetext —, dann nach außen in eine EnumMap.

18:46 Diese Trennung sauber hinzubekommen ist eine Fähigkeit, die weit über Enums hinaus trägt. Testen Sie beide Stellen, damit die Entscheidung dokumentiert ist. Der erste Punkt ist reine Gewohnheit: HashMap nehmen, weil sie einem zuerst einfällt. Funktioniert, ist nur unnötig. Der zweite ist ein technisches Detail — EnumMap braucht beim Erzeugen das Klassenobjekt, sonst wüsste sie nicht, wie viele Plätze sie anlegen muss.

19:11 Der dritte ist die Vermischung von Fachlichkeit und Oberfläche, die wir eben besprochen haben. Und der vierte betrifft die Kapselung: Ein EnumSet als öffentliche Konstante ist veränderlich — wer es herausgibt, gibt auch die Möglichkeit heraus, es zu ändern. Das Wichtigste zuerst: Ein Enum ist eine Klasse mit fester Instanzenmenge. Aus diesem Satz folgt alles andere in diesem Modul.

19:34 Gebundene Werte gehören an die Konstante, die Rückwärtssuche in eine eigene statische Methode — und dort entscheiden Sie bewusst, was bei unbekannten Werten passiert. Verhalten je Konstante geht auf vier Wegen, und die Länge der Logik entscheidet. EnumSet und EnumMap sind spezialisiert und fast immer die bessere Wahl. Im nächsten Modul wechseln wir das Thema und schauen uns an, was passiert, wenn Typen ineinander verschachtelt werden.