Zum Inhalt springen

Enums

Ein Konto kann aktiv, gesperrt oder gekündigt sein – und sonst nichts. Wie speichert man so etwas? Als Zahl 0, 1, 2? Als Text "aktiv"? Beides lädt zu Fehlern ein: Was bedeutet 7? Und wer fängt "gesperrrt" mit drei r ab? Für Werte aus einer festen Auswahl gibt es in Java einen eigenen Typ: das Enum.

  • ein Enum anlegen und seine Werte benutzen
  • einem Enum eigene Daten und Methoden geben
  • mit switch über ein Enum entscheiden – und dabei keinen Fall vergessen
  • erklären, warum man Enums mit == vergleichen darf

Ausgangsstand für 15-bank

⤓ bank-enums.zip herunterladen

Wer die letzte Stufe nicht fertig hat, startet hiermit: Rechtsklick auf das Projekt15-bank → Import… → General → Archive File → die ZIP-Datei wählen →Finish. Vorhandene Dateien werden dabei – nach Rückfrage – überschrieben.

Enthält: Betrag.java, Buchung.java, Kunde.java, Konto.java, Bankdemo.java, BetragTest.java, BuchungTest.java, KontoTest.java

public enum Kontostatus {
AKTIV, GESPERRT, GEKUENDIGT
}
  • enum statt class – sonst sieht es aus wie eine Klasse und steht auch in einer eigenen Datei Kontostatus.java.
  • Die Konstanten werden nach Konvention großgeschrieben.
  • Es gibt genau diese drei Werte – mehr kann niemand erzeugen. Ein new Kontostatus() meldet Eclipse als Fehler: Cannot instantiate the type Kontostatus.

Benutzt wird ein Enum über den Typnamen:

Kontostatus status = Kontostatus.GESPERRT;
if (status == Kontostatus.GESPERRT) {
System.out.println("Bitte an die Filiale wenden.");
}

Ein paar Methoden hat jedes Enum automatisch:

Aufruf Ergebnis
Kontostatus.values() ein Array mit allen Werten, in der Reihenfolge der Deklaration
Kontostatus.valueOf("GESPERRT") die Konstante zu diesem Namen
status.name() der Name als Text, z. B. "GESPERRT"
status.toString() ebenfalls der Name – lässt sich aber überschreiben
status.ordinal() die Position in der Deklaration, ab 0

valueOf verzeiht keinen Tippfehler und auch keine Kleinschreibung: valueOf("gesperrt") bricht mit einer IllegalArgumentException: No enum constant de.drv.bank.Kontostatus.gesperrt ab.

Ein Enum ist eine vollwertige Klasse: Es kann Felder, einen Konstruktor und Methoden haben. Damit wandern die Regeln zum jeweiligen Status dorthin, wo sie hingehören:

Kontostatus.java
package de.drv.bank;
public enum Kontostatus {
AKTIV("aktiv", true, true),
GESPERRT("gesperrt", true, false),
GEKUENDIGT("gekündigt", false, false);
private final String bezeichnung;
private final boolean einzahlungErlaubt;
private final boolean auszahlungErlaubt;
Kontostatus(String bezeichnung, boolean einzahlungErlaubt, boolean auszahlungErlaubt) {
this.bezeichnung = bezeichnung;
this.einzahlungErlaubt = einzahlungErlaubt;
this.auszahlungErlaubt = auszahlungErlaubt;
}
public String getBezeichnung() {
return bezeichnung;
}
public boolean isEinzahlungErlaubt() {
return einzahlungErlaubt;
}
public boolean isAuszahlungErlaubt() {
return auszahlungErlaubt;
}
}
  • Hinter jeder Konstante stehen in Klammern die Werte für den Konstruktor. Die Liste der Konstanten endet mit einem Semikolon.
  • Der Konstruktor ist automatisch privat – nur das Enum selbst erzeugt seine Konstanten. public davor meldet Eclipse: Illegal modifier for the enum constructor; only private is permitted.
  • Ein gesperrtes Konto nimmt noch Geld an, zahlt aber nichts mehr aus. Ein gekündigtes macht gar nichts mehr. Diese Regeln stehen jetzt an einer Stelle – lesbar wie eine Tabelle.
Konto.java (Ausschnitte)
private Kontostatus status;
public Konto(Kunde inhaber) {
// …
this.status = Kontostatus.AKTIV;
}
public Kontostatus getStatus() {
return status;
}
public void sperren() {
if (status != Kontostatus.AKTIV) {
throw new IllegalStateException("Nur ein aktives Konto kann gesperrt werden.");
}
status = Kontostatus.GESPERRT;
}
public void entsperren() {
if (status != Kontostatus.GESPERRT) {
throw new IllegalStateException("Das Konto ist nicht gesperrt.");
}
status = Kontostatus.AKTIV;
}
public void kuendigen() {
if (status == Kontostatus.GEKUENDIGT) {
throw new IllegalStateException("Das Konto ist bereits gekündigt.");
}
if (!kontostand.equals(Betrag.NULL)) {
throw new IllegalStateException("Nur ein leeres Konto kann gekündigt werden.");
}
status = Kontostatus.GEKUENDIGT;
}
public void einzahlen(Betrag betrag) {
pruefePositiv(betrag);
if (!status.isEinzahlungErlaubt()) {
throw new IllegalStateException("Keine Einzahlung möglich – Konto " + status.getBezeichnung() + ".");
}
kontostand = kontostand.plus(betrag);
}

abheben prüft entsprechend isAuszahlungErlaubt().

Es gibt kein setStatus. Der Status ändert sich nur über sperren, entsperren und kuendigen – und jede dieser Methoden prüft, ob der Wechsel erlaubt ist. Ein gekündigtes Konto lässt sich nicht wieder entsperren, ein Konto mit Guthaben nicht kündigen.

Neu ist IllegalStateException. Der Unterschied zur bekannten IllegalArgumentException:

Exception bedeutet Beispiel
IllegalArgumentException Der übergebene Wert ist ungültig. Einzahlung von −5 €
IllegalStateException Der Wert wäre in Ordnung – aber das Objekt ist gerade nicht in dem Zustand dafür. Auszahlung von einem gesperrten Konto

Was passiert bei einer Überweisung auf ein gekündigtes Konto? ueberweisen hebt zuerst vom eigenen Konto ab – und dann scheitert einzahlen auf dem Zielkonto. Das Geld wäre abgebucht, aber nirgends angekommen. Deshalb prüft ueberweisen das Zielkonto vorher:

Konto.java (Ausschnitt)
public boolean ueberweisen(Konto ziel, Betrag betrag) {
if (!ziel.status.isEinzahlungErlaubt()) {
throw new IllegalStateException("Das Zielkonto nimmt keine Zahlungen an – Konto "
+ ziel.status.getBezeichnung() + ".");
}
if (!abheben(betrag)) {
return false;
}
ziel.einzahlen(betrag);
return true;
}

Eine Regel, die in der Softwareentwicklung immer wieder gilt: Erst alles prüfen, dann etwas verändern.

Bankdemo.java (Ausschnitt)
public static String hinweis(Kontostatus status) {
return switch (status) {
case AKTIV -> "Alles in Ordnung.";
case GESPERRT -> "Bitte wenden Sie sich an Ihre Filiale.";
case GEKUENDIGT -> "Dieses Konto ist aufgelöst.";
};
}
  • In den case-Zeilen steht nur der Name der Konstante – ohne Kontostatus. davor.
  • Es gibt kein default – und das ist ein Vorteil. Weil der Compiler alle Werte des Enums kennt, prüft er, ob jeder Fall abgedeckt ist. Fehlt einer, meldet Eclipse: A Switch expression should cover all possible values.
  • Kommt später ein neuer Status dazu, zeigt Eclipse jede Stelle, an der er noch fehlt. Mit einem default würde der neue Status still in diesem Zweig landen – egal, ob das passt.

Naheliegend wäre auch ein Enum Kontoart { GIRO, SPAR }. Aber Giro- und Sparkonten unterscheiden sich nicht nur in einem Wert, sondern im Verhalten: Ein Girokonto darf überzogen werden, ein Sparkonto bringt Zinsen. Mit einem Enum stünden in jeder Methode Fallunterscheidungen. Für unterschiedliches Verhalten gibt es ein anderes Werkzeug – die Vererbung, unser nächstes Thema.

Faustregel: Ein Enum passt für eine feste Auswahl von Werten, die sich im Verhalten nur wenig unterscheiden.

Meldung bzw. Symptom Ursache
A Switch expression should cover all possible values Ein Wert des Enums fehlt im switch-Ausdruck
The enum constant … needs a corresponding case label (Warnung) Dasselbe bei einem switch ohne Rückgabewert
Cannot instantiate the type Kontostatus new bei einem Enum – nur die vorhandenen Konstanten benutzen
AKTIV cannot be resolved to a variable Typname vergessen: Kontostatus.AKTIV (nur im case ohne)
Illegal modifier for the enum constructor public vor dem Konstruktor eines Enums
IllegalArgumentException: No enum constant … valueOf mit falsch geschriebenem Namen
  1. Lege Kontostatus an und gib dem Konto den Status mit sperren, entsperren und kuendigen wie oben gezeigt.

    Lösung
    Kontostatus.java
    package de.drv.bank;
    public enum Kontostatus {
    AKTIV("aktiv", true, true),
    GESPERRT("gesperrt", true, false),
    GEKUENDIGT("gekündigt", false, false);
    private final String bezeichnung;
    private final boolean einzahlungErlaubt;
    private final boolean auszahlungErlaubt;
    Kontostatus(String bezeichnung, boolean einzahlungErlaubt, boolean auszahlungErlaubt) {
    this.bezeichnung = bezeichnung;
    this.einzahlungErlaubt = einzahlungErlaubt;
    this.auszahlungErlaubt = auszahlungErlaubt;
    }
    public String getBezeichnung() {
    return bezeichnung;
    }
    public boolean isEinzahlungErlaubt() {
    return einzahlungErlaubt;
    }
    public boolean isAuszahlungErlaubt() {
    return auszahlungErlaubt;
    }
    }
    Lösung

    Auch toString zeigt jetzt den Status mit an.

    Konto.java
    package de.drv.bank;
    import java.time.LocalDate;
    public class Konto {
    public static final String BANKLEITZAHL = "12345678";
    private static int naechsteNummer = 1001;
    private final int kontonummer;
    private final Kunde inhaber;
    private final LocalDate eroeffnetAm;
    private Betrag kontostand;
    private Kontostatus status;
    public Konto(Kunde inhaber) {
    if (inhaber == null) {
    throw new IllegalArgumentException("Ein Konto braucht einen Inhaber.");
    }
    this.kontonummer = naechsteNummer;
    naechsteNummer++;
    this.inhaber = inhaber;
    this.eroeffnetAm = LocalDate.now();
    this.kontostand = Betrag.NULL;
    this.status = Kontostatus.AKTIV;
    }
    public Konto(Kunde inhaber, Betrag startguthaben) {
    this(inhaber);
    einzahlen(startguthaben);
    }
    public int getKontonummer() {
    return kontonummer;
    }
    public Kunde getInhaber() {
    return inhaber;
    }
    public LocalDate getEroeffnetAm() {
    return eroeffnetAm;
    }
    public Betrag getKontostand() {
    return kontostand;
    }
    public Kontostatus getStatus() {
    return status;
    }
    public void sperren() {
    if (status != Kontostatus.AKTIV) {
    throw new IllegalStateException("Nur ein aktives Konto kann gesperrt werden.");
    }
    status = Kontostatus.GESPERRT;
    }
    public void entsperren() {
    if (status != Kontostatus.GESPERRT) {
    throw new IllegalStateException("Das Konto ist nicht gesperrt.");
    }
    status = Kontostatus.AKTIV;
    }
    public void kuendigen() {
    if (status == Kontostatus.GEKUENDIGT) {
    throw new IllegalStateException("Das Konto ist bereits gekündigt.");
    }
    if (!kontostand.equals(Betrag.NULL)) {
    throw new IllegalStateException("Nur ein leeres Konto kann gekündigt werden.");
    }
    status = Kontostatus.GEKUENDIGT;
    }
    public void einzahlen(Betrag betrag) {
    pruefePositiv(betrag);
    if (!status.isEinzahlungErlaubt()) {
    throw new IllegalStateException("Keine Einzahlung möglich – Konto " + status.getBezeichnung() + ".");
    }
    kontostand = kontostand.plus(betrag);
    }
    public boolean abheben(Betrag betrag) {
    pruefePositiv(betrag);
    if (!status.isAuszahlungErlaubt()) {
    throw new IllegalStateException("Keine Auszahlung möglich – Konto " + status.getBezeichnung() + ".");
    }
    if (betrag.istGroesserAls(kontostand)) {
    return false;
    }
    kontostand = kontostand.minus(betrag);
    return true;
    }
    public boolean ueberweisen(Konto ziel, Betrag betrag) {
    if (!ziel.status.isEinzahlungErlaubt()) {
    throw new IllegalStateException("Das Zielkonto nimmt keine Zahlungen an – Konto "
    + ziel.status.getBezeichnung() + ".");
    }
    if (!abheben(betrag)) {
    return false;
    }
    ziel.einzahlen(betrag);
    return true;
    }
    public String getKontokennung() {
    return BANKLEITZAHL + "/" + kontonummer;
    }
    @Override
    public String toString() {
    return "Konto " + getKontokennung() + " (" + inhaber.getName() + ", " + status.getBezeichnung() + "): "
    + kontostand;
    }
    @Override
    public boolean equals(Object obj) {
    if (this == obj) {
    return true;
    }
    if (!(obj instanceof Konto anderes)) {
    return false;
    }
    return kontonummer == anderes.kontonummer;
    }
    @Override
    public int hashCode() {
    return Integer.hashCode(kontonummer);
    }
    private static void pruefePositiv(Betrag betrag) {
    if (betrag == null || !betrag.istGroesserAls(Betrag.NULL)) {
    throw new IllegalArgumentException("Der Betrag muss größer als 0 sein: " + betrag);
    }
    }
    }
  2. Ergänze KontoTest um Tests für den Status: Ein neues Konto ist aktiv, ein gesperrtes nimmt Einzahlungen an, zahlt aber nicht aus, Kündigen geht nur bei leerem Konto, und bei einer Überweisung auf ein gekündigtes Konto geht kein Geld verloren.

    Ob eine Exception kommt, prüfst du so:

    assertThrows(IllegalStateException.class, () -> konto.abheben(Betrag.euro(5)));

    () -> … ist ein Lambda: Code, der nicht sofort, sondern erst von assertThrows ausgeführt wird. Mehr dazu in der zweiten Woche – hier kannst du die Schreibweise einfach übernehmen.

    Lösung
    KontoTest.java
    package de.drv.bank;
    import static org.junit.jupiter.api.Assertions.assertEquals;
    import static org.junit.jupiter.api.Assertions.assertFalse;
    import static org.junit.jupiter.api.Assertions.assertNotEquals;
    import static org.junit.jupiter.api.Assertions.assertThrows;
    import static org.junit.jupiter.api.Assertions.assertTrue;
    import java.time.LocalDate;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class KontoTest {
    private final Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
    @Test
    @DisplayName("Ein neues Konto ist leer")
    void neuesKontoIstLeer() {
    assertEquals(Betrag.NULL, new Konto(anna).getKontostand());
    }
    @Test
    @DisplayName("Startguthaben wird gebucht")
    void startguthaben() {
    assertEquals(Betrag.euro(100), new Konto(anna, Betrag.euro(100)).getKontostand());
    }
    @Test
    @DisplayName("Einzahlen erhöht den Kontostand")
    void einzahlen() {
    Konto konto = new Konto(anna);
    konto.einzahlen(Betrag.euro(19, 99));
    konto.einzahlen(Betrag.euro(0, 1));
    assertEquals(Betrag.euro(20), konto.getKontostand());
    }
    @Test
    @DisplayName("Abheben mit Deckung")
    void abhebenMitDeckung() {
    Konto konto = new Konto(anna, Betrag.euro(100));
    assertTrue(konto.abheben(Betrag.euro(100)));
    assertEquals(Betrag.NULL, konto.getKontostand());
    }
    @Test
    @DisplayName("Abheben ohne Deckung ändert nichts")
    void abhebenOhneDeckung() {
    Konto konto = new Konto(anna, Betrag.euro(100));
    assertFalse(konto.abheben(Betrag.euro(100, 1)));
    assertEquals(Betrag.euro(100), konto.getKontostand());
    }
    @Test
    @DisplayName("Überweisen bucht auf beiden Konten")
    void ueberweisen() {
    Konto von = new Konto(anna, Betrag.euro(100));
    Konto nach = new Konto(anna);
    assertTrue(von.ueberweisen(nach, Betrag.euro(30)));
    assertEquals(Betrag.euro(70), von.getKontostand());
    assertEquals(Betrag.euro(30), nach.getKontostand());
    }
    @Test
    @DisplayName("Überweisen ohne Deckung ändert keines der Konten")
    void ueberweisenOhneDeckung() {
    Konto von = new Konto(anna, Betrag.euro(10));
    Konto nach = new Konto(anna);
    assertFalse(von.ueberweisen(nach, Betrag.euro(30)));
    assertEquals(Betrag.euro(10), von.getKontostand());
    assertEquals(Betrag.NULL, nach.getKontostand());
    }
    @Test
    @DisplayName("Jedes Konto bekommt eine eigene Nummer")
    void eigeneNummern() {
    assertNotEquals(new Konto(anna).getKontonummer(), new Konto(anna).getKontonummer());
    }
    @Test
    @DisplayName("Ein Konto ist gleich zu sich selbst, aber nicht zu einem anderen")
    void gleichheit() {
    Konto konto = new Konto(anna);
    Konto dasselbe = konto;
    assertEquals(konto, dasselbe);
    assertNotEquals(konto, new Konto(anna));
    assertEquals(konto.hashCode(), dasselbe.hashCode());
    }
    @Test
    @DisplayName("toString enthält Kontokennung, Inhaber und Kontostand")
    void textdarstellung() {
    Konto konto = new Konto(anna, Betrag.euro(19, 99));
    String text = konto.toString();
    assertTrue(text.contains(konto.getKontokennung()));
    assertTrue(text.contains("Anna Muster"));
    assertTrue(text.contains("19,99 €"));
    }
    @Test
    @DisplayName("Ein neues Konto ist aktiv")
    void neuesKontoIstAktiv() {
    assertEquals(Kontostatus.AKTIV, new Konto(anna).getStatus());
    }
    @Test
    @DisplayName("Ein gesperrtes Konto nimmt Einzahlungen an, zahlt aber nicht aus")
    void gesperrt() {
    Konto konto = new Konto(anna, Betrag.euro(100));
    konto.sperren();
    konto.einzahlen(Betrag.euro(5));
    assertEquals(Betrag.euro(105), konto.getKontostand());
    assertThrows(IllegalStateException.class, () -> konto.abheben(Betrag.euro(5)));
    }
    @Test
    @DisplayName("Entsperren macht ein Konto wieder aktiv")
    void entsperren() {
    Konto konto = new Konto(anna);
    konto.sperren();
    konto.entsperren();
    assertEquals(Kontostatus.AKTIV, konto.getStatus());
    }
    @Test
    @DisplayName("Kündigen geht nur bei leerem Konto")
    void kuendigen() {
    Konto konto = new Konto(anna, Betrag.euro(10));
    assertThrows(IllegalStateException.class, () -> konto.kuendigen());
    konto.abheben(Betrag.euro(10));
    konto.kuendigen();
    assertEquals(Kontostatus.GEKUENDIGT, konto.getStatus());
    }
    @Test
    @DisplayName("Keine Überweisung auf ein gekündigtes Konto – und kein Geld geht verloren")
    void ueberweisenAufGekuendigtesKonto() {
    Konto von = new Konto(anna, Betrag.euro(100));
    Konto nach = new Konto(anna);
    nach.kuendigen();
    assertThrows(IllegalStateException.class, () -> von.ueberweisen(nach, Betrag.euro(30)));
    assertEquals(Betrag.euro(100), von.getKontostand());
    }
    }
  3. Was wird ausgegeben? Überlege erst, dann probiere es aus.

    Kontostatus s = Kontostatus.valueOf("GESPERRT");
    System.out.println(s);
    System.out.println(s.name() + " " + s.ordinal());
    System.out.println(s == Kontostatus.GESPERRT);
    System.out.println(Kontostatus.values().length);
    Lösung
    GESPERRT
    GESPERRT 1
    true
    3
  4. Ein frisch eröffnetes Konto soll zunächst den Status NEU haben: Einzahlungen sind erlaubt, Auszahlungen erst nach einer Freischaltung. Füge NEU zum Enum hinzu. Was meldet Eclipse in Bankdemo? Ergänze danach eine Methode freischalten().

    Lösung

    Eclipse markiert den switch in hinweis rot: A Switch expression should cover all possible values – der neue Fall fehlt. Genau das ist der Vorteil eines switch ohne default: Kein Ort, an dem der neue Status bedacht werden muss, wird übersehen.

    freischalten() funktioniert wie entsperren(): nur erlaubt, wenn der Status NEU ist, danach AKTIV. Der Konstruktor setzt dann NEU statt AKTIV – und die Tests, die ein aktives Konto erwarten, schlagen fehl. Auch das zeigt: Die Tests bemerken jede Änderung am Verhalten.

Lösung
Bankdemo.java
package de.drv.bank;
import java.time.LocalDate;
public class Bankdemo {
public static void main(String[] args) {
Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
Konto konto = new Konto(anna, Betrag.euro(250));
konto.sperren();
konto.einzahlen(Betrag.euro(50));
System.out.println(konto);
System.out.println(hinweis(konto.getStatus()));
for (Kontostatus status : Kontostatus.values()) {
System.out.println(status + " – " + status.getBezeichnung()
+ ", Auszahlung erlaubt: " + status.isAuszahlungErlaubt());
}
konto.abheben(Betrag.euro(10));
}
public static String hinweis(Kontostatus status) {
return switch (status) {
case AKTIV -> "Alles in Ordnung.";
case GESPERRT -> "Bitte wenden Sie sich an Ihre Filiale.";
case GEKUENDIGT -> "Dieses Konto ist aufgelöst.";
};
}
}