Zum Inhalt springen

Abstrakte Klassen und Polymorphie

Geh in eine Bank und eröffne „ein Konto“. Die erste Frage wird sein: Was für eins? Ein Girokonto, ein Sparkonto? Ein Konto an sich gibt es nicht – nur Konten einer bestimmten Art. Genau das kann Java ausdrücken.

  • abstrakte Klassen und abstrakte Methoden schreiben
  • verschiedene Unterklassen über ihre gemeinsame Oberklasse benutzen
  • erklären, was Polymorphie ist und wozu sie gut ist
  • Methoden mit final vor dem Überschreiben schützen
  • protected gezielt einsetzen

Ausgangsstand für 15-bank

⤓ bank-abstrakt.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, Kontostatus.java, GiroKonto.java, SparKonto.java, Bankdemo.java, BetragTest.java, BuchungTest.java, KontoTest.java, GiroKontoTest.java, SparKontoTest.java

Konto.java (Ausschnitte)
public abstract class Konto {
// … Felder, Konstruktor wie bisher
public abstract String getKontoart();
public abstract void monatsabschluss();
// … alle übrigen Methoden wie bisher
}
  • abstract class heißt: Von dieser Klasse gibt es keine eigenen Objekte. new Konto(anna) meldet Eclipse jetzt: Cannot instantiate the type Konto. Erzeugt werden nur Giro- und Sparkonten.
  • Eine abstrakte Klasse ist trotzdem eine vollwertige Klasse: Sie hat Felder, einen Konstruktor (den die Unterklassen mit super(…) aufrufen) und fertige Methoden.
  • Eine abstrakte Methode hat keinen Rumpf – nur die Kopfzeile mit Semikolon. Sie sagt: „Jedes Konto kann das – aber wie, entscheidet die jeweilige Kontoart.“

Jede Unterklasse muss die abstrakten Methoden umsetzen. Vergisst sie eine, meldet Eclipse: The type GiroKonto must implement the inherited abstract method Konto.monatsabschluss(). Eine Kontoart, die keinen Monatsabschluss kennt, kann es also gar nicht geben.

Statt "Giro" + super.toString() – ein Kunstgriff aus dem letzten Kapitel – fragt toString im Konto jetzt einfach die Kontoart ab:

Konto.java (Ausschnitt)
@Override
public String toString() {
return getKontoart() + " " + getKontokennung() + " (" + inhaber.getName() + ", "
+ status.getBezeichnung() + "): " + kontostand;
}
GiroKonto.java (Ausschnitt)
@Override
public String getKontoart() {
return "Girokonto";
}

toString steht im abstrakten Konto und ruft eine abstrakte Methode auf – die es dort gar nicht gibt. Das funktioniert, weil toString immer auf einem konkreten Objekt läuft: einem Giro- oder Sparkonto, das getKontoart() umgesetzt hat.

Am Monatsende geschieht bei jeder Kontoart etwas anderes: Das Girokonto zahlt eine Kontoführungsgebühr, das Sparkonto bekommt Zinsen.

GiroKonto.java (Ausschnitt)
public static final Betrag KONTOFUEHRUNGSGEBUEHR = Betrag.euro(4, 90);
@Override
public void monatsabschluss() {
belasten(KONTOFUEHRUNGSGEBUEHR);
}
SparKonto.java (Ausschnitt)
@Override
public void monatsabschluss() {
zinsenGutschreiben();
}

Vereinfachung für unser Beispiel: Der Zinssatz gilt pro Monatsabschluss.

Die Gebühr wird immer fällig – auch wenn auf dem Konto nicht genug Geld ist. abheben würde sie verweigern. Das Konto bekommt deshalb eine Methode, die ohne Deckungsprüfung bucht:

Konto.java (Ausschnitt)
protected void belasten(Betrag betrag) {
pruefePositiv(betrag);
kontostand = kontostand.minus(betrag);
}

Diese Methode darf auf keinen Fall jeder aufrufen – sonst wäre die Deckungsprüfung wieder ausgehebelt. Aber die Unterklassen brauchen sie. Genau dafür ist protected da: sichtbar für Unterklassen, nicht für beliebige andere Klassen. Aus einem anderen Package meldet Eclipse: The method belasten(Betrag) from the type Konto is not visible.

Jetzt kommt alles zusammen: Eine Bank verwaltet beliebige Konten – Giro- und Sparkonten gemischt – in einem Array vom Typ Konto:

Bank.java
package de.drv.bank;
public class Bank {
private final String name;
private final Konto[] konten;
private int anzahl;
public Bank(String name, int kapazitaet) {
this.name = name;
this.konten = new Konto[kapazitaet];
this.anzahl = 0;
}
public String getName() {
return name;
}
public int getAnzahlKonten() {
return anzahl;
}
public void aufnehmen(Konto konto) {
if (konto == null) {
throw new IllegalArgumentException("Kein Konto angegeben.");
}
if (anzahl == konten.length) {
throw new IllegalStateException("Die Bank hat keinen Platz für weitere Konten.");
}
konten[anzahl] = konto;
anzahl++;
}
public Konto suche(int kontonummer) {
for (int i = 0; i < anzahl; i++) {
if (konten[i].getKontonummer() == kontonummer) {
return konten[i];
}
}
return null;
}
public Betrag getGesamtbestand() {
Betrag summe = Betrag.NULL;
for (int i = 0; i < anzahl; i++) {
summe = summe.plus(konten[i].getKontostand());
}
return summe;
}
public void monatsabschluss() {
for (int i = 0; i < anzahl; i++) {
konten[i].monatsabschluss();
}
}
public String uebersicht() {
StringBuilder text = new StringBuilder(name).append('\n');
for (int i = 0; i < anzahl; i++) {
text.append(" ").append(konten[i]).append('\n');
}
text.append(" Gesamtbestand: ").append(getGesamtbestand());
return text.toString();
}
}

Das Array ist vom Typ Konto[] – und darf Giro- und Sparkonten enthalten, denn beide sind Konten. anzahl zählt, wie viele Plätze schon belegt sind; das Array hat eine feste Größe (eine Liste, die mitwächst, kommt in der zweiten Woche).

Terminal-Fenster
Musterbank
Girokonto 12345678/1001 (Anna Muster, aktiv): 100,00 €, Dispo 500,00 €
Sparkonto 12345678/1002 (Anna Muster, aktiv): 2.000,00 €, Zinssatz 0,50 %
Girokonto 12345678/1003 (Ben Beispiel, aktiv): 0,00 €, Dispo 200,00 €
Gesamtbestand: 2.100,00 €
Nach dem Monatsabschluss:
Musterbank
Girokonto 12345678/1001 (Anna Muster, aktiv): 95,10 €, Dispo 500,00 €
Sparkonto 12345678/1002 (Anna Muster, aktiv): 2.010,00 €, Zinssatz 0,50 %
Girokonto 12345678/1003 (Ben Beispiel, aktiv): -4,90 €, Dispo 200,00 €
Gesamtbestand: 2.100,20 €

Schau dir monatsabschluss() in der Bank genau an:

for (int i = 0; i < anzahl; i++) {
konten[i].monatsabschluss();
}

Eine Zeile, ein Aufruf – und doch passiert bei jedem Konto etwas anderes: Anna zahlt Gebühr, ihr Sparbuch bekommt Zinsen, Ben rutscht durch die Gebühr in den Dispo. Die Bank weiß nicht einmal, welche Kontoarten es gibt. Sie kennt nur „Konto“ – und jedes Konto weiß selbst, was es zu tun hat.

Das heißt Polymorphie (griechisch: Vielgestaltigkeit): Derselbe Aufruf führt je nach Objekt zu unterschiedlichem Verhalten.

bestimmt durch Beispiel
Welche Methoden man aufrufen darf den Typ der Variable konten[i] ist ein Konto – also nur, was Konto kennt
Welche Fassung der Methode läuft den Typ des Objekts das monatsabschluss() des Giro- bzw. Sparkontos

Der große Gewinn: Kommt morgen ein Tagesgeldkonto dazu, schreibt man eine neue Unterklasse mit ihrem eigenen monatsabschluss() – und die Bank funktioniert, ohne dass man an ihr eine einzige Zeile ändert.

Manchmal braucht man eine Methode, die nur eine Unterklasse hat. Dann hilft instanceof mit einer Mustervariable – du kennst die Schreibweise vom equals:

Konto gefunden = bank.suche(1002);
if (gefunden instanceof SparKonto spar) {
System.out.println("Gefunden: " + spar);
// spar.zinsenGutschreiben() wäre hier möglich
}

Setze das sparsam ein. Wer häufig nach der Art fragt („Bist du ein Sparkonto? Dann mach dies, sonst das“), hat meist eine Methode vergessen, die in die Oberklasse gehört – so wie monatsabschluss().

einzahlen, abheben und ueberweisen enthalten die wichtigen Regeln: Status, Deckung, positive Beträge. Eine Unterklasse, die abheben überschreibt, könnte sie alle umgehen. Deshalb sind diese Methoden jetzt final:

Konto.java (Ausschnitt)
public final boolean abheben(Betrag betrag) {
// …
}

Eine final-Methode lässt sich nicht überschreiben (Cannot override the final method from Konto). Die Unterklassen bestimmen nur noch, was sie wirklich unterscheidet: den verfügbaren Betrag, die Kontoart, den Monatsabschluss. Diese Arbeitsteilung – die Oberklasse legt den Ablauf fest, die Unterklassen füllen einzelne Schritte – ist ein bewährtes Muster.

Weil Konto jetzt abstrakt ist, kann KontoTest kein new Konto(anna) mehr schreiben. Die Tests erzeugen stattdessen ein Girokonto ohne Dispo – das verhält sich genau wie das bisherige Konto:

KontoTest.java (Ausschnitt)
/** Konto ist abstrakt – getestet wird mit einem Girokonto ohne Dispo, das sich wie ein Konto verhält. */
private Konto konto() {
return new GiroKonto(anna, Betrag.NULL);
}

Die erwarteten Werte in den Tests haben sich dabei nicht geändert – und alle Tests sind weiter grün. So sieht ein guter Umbau aus: Die Struktur ändert sich, das Verhalten bleibt gleich, und die Tests beweisen es.

Meldung in Eclipse Ursache
Cannot instantiate the type Konto new bei einer abstrakten Klasse
The type … must implement the inherited abstract method … Eine Unterklasse setzt eine abstrakte Methode nicht um
Abstract methods do not specify a body Abstrakte Methode mit { … } statt Semikolon
The type … must be an abstract class to define abstract methods Abstrakte Methode in einer nicht abstrakten Klasse
Cannot override the final method from Konto Eine final-Methode soll überschrieben werden
The method belasten(Betrag) from the type Konto is not visible protected-Methode aus einem anderen Package aufgerufen
  1. Mache Konto abstrakt mit getKontoart() und monatsabschluss(). Setze beide in GiroKonto und SparKonto um. Passe die Tests an – ohne die erwarteten Werte zu ändern.

    Lösung

    Der Konstruktor mit Startguthaben ist entfallen: Die Unterklassen hatten ohnehin keinen, und für ein abstraktes Konto wird er nicht mehr gebraucht.

    Konto.java
    package de.drv.bank;
    import java.time.LocalDate;
    public abstract 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 int getKontonummer() {
    return kontonummer;
    }
    public Kunde getInhaber() {
    return inhaber;
    }
    public LocalDate getEroeffnetAm() {
    return eroeffnetAm;
    }
    public Betrag getKontostand() {
    return kontostand;
    }
    public abstract String getKontoart();
    public abstract void monatsabschluss();
    public Betrag getVerfuegbarerBetrag() {
    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 final void einzahlen(Betrag betrag) {
    pruefePositiv(betrag);
    if (!status.isEinzahlungErlaubt()) {
    throw new IllegalStateException("Keine Einzahlung möglich – Konto " + status.getBezeichnung() + ".");
    }
    kontostand = kontostand.plus(betrag);
    }
    public final boolean abheben(Betrag betrag) {
    pruefePositiv(betrag);
    if (!status.isAuszahlungErlaubt()) {
    throw new IllegalStateException("Keine Auszahlung möglich – Konto " + status.getBezeichnung() + ".");
    }
    if (betrag.istGroesserAls(getVerfuegbarerBetrag())) {
    return false;
    }
    kontostand = kontostand.minus(betrag);
    return true;
    }
    public final 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;
    }
    protected void belasten(Betrag betrag) {
    pruefePositiv(betrag);
    kontostand = kontostand.minus(betrag);
    }
    public String getKontokennung() {
    return BANKLEITZAHL + "/" + kontonummer;
    }
    @Override
    public String toString() {
    return getKontoart() + " " + 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);
    }
    }
    }
    Lösung
    GiroKonto.java
    package de.drv.bank;
    public class GiroKonto extends Konto {
    public static final Betrag KONTOFUEHRUNGSGEBUEHR = Betrag.euro(4, 90);
    private final Betrag dispo;
    public GiroKonto(Kunde inhaber, Betrag dispo) {
    super(inhaber);
    if (dispo == null || dispo.istNegativ()) {
    throw new IllegalArgumentException("Der Dispo darf nicht negativ sein: " + dispo);
    }
    this.dispo = dispo;
    }
    public Betrag getDispo() {
    return dispo;
    }
    @Override
    public String getKontoart() {
    return "Girokonto";
    }
    @Override
    public void monatsabschluss() {
    belasten(KONTOFUEHRUNGSGEBUEHR);
    }
    @Override
    public Betrag getVerfuegbarerBetrag() {
    return getKontostand().plus(dispo);
    }
    @Override
    public String toString() {
    return super.toString() + ", Dispo " + dispo;
    }
    }
    Lösung
    SparKonto.java
    package de.drv.bank;
    import java.util.Locale;
    public class SparKonto extends Konto {
    private final double zinssatz;
    public SparKonto(Kunde inhaber, double zinssatz) {
    super(inhaber);
    if (zinssatz < 0) {
    throw new IllegalArgumentException("Der Zinssatz darf nicht negativ sein: " + zinssatz);
    }
    this.zinssatz = zinssatz;
    }
    public double getZinssatz() {
    return zinssatz;
    }
    @Override
    public String getKontoart() {
    return "Sparkonto";
    }
    @Override
    public void monatsabschluss() {
    zinsenGutschreiben();
    }
    public Betrag zinsenGutschreiben() {
    Betrag zinsen = getKontostand().prozent(zinssatz);
    if (zinsen.istGroesserAls(Betrag.NULL)) {
    einzahlen(zinsen);
    }
    return zinsen;
    }
    @Override
    public String toString() {
    return String.format(Locale.GERMANY, "%s, Zinssatz %.2f %%", super.toString(), zinssatz);
    }
    }
    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));
    /** Konto ist abstrakt – getestet wird mit einem Girokonto ohne Dispo, das sich wie ein Konto verhält. */
    private Konto konto() {
    return new GiroKonto(anna, Betrag.NULL);
    }
    private Konto konto(Betrag startguthaben) {
    Konto konto = konto();
    konto.einzahlen(startguthaben);
    return konto;
    }
    @Test
    @DisplayName("Ein neues Konto ist leer")
    void neuesKontoIstLeer() {
    assertEquals(Betrag.NULL, konto().getKontostand());
    }
    @Test
    @DisplayName("Startguthaben wird gebucht")
    void startguthaben() {
    assertEquals(Betrag.euro(100), konto(Betrag.euro(100)).getKontostand());
    }
    @Test
    @DisplayName("Einzahlen erhöht den Kontostand")
    void einzahlen() {
    Konto konto = konto();
    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 = konto(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 = konto(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 = konto(Betrag.euro(100));
    Konto nach = konto();
    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 = konto(Betrag.euro(10));
    Konto nach = konto();
    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(konto().getKontonummer(), konto().getKontonummer());
    }
    @Test
    @DisplayName("Ein Konto ist gleich zu sich selbst, aber nicht zu einem anderen")
    void gleichheit() {
    Konto konto = konto();
    Konto dasselbe = konto;
    assertEquals(konto, dasselbe);
    assertNotEquals(konto, konto());
    assertEquals(konto.hashCode(), dasselbe.hashCode());
    }
    @Test
    @DisplayName("toString enthält Kontokennung, Inhaber und Kontostand")
    void textdarstellung() {
    Konto konto = konto(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, konto().getStatus());
    }
    @Test
    @DisplayName("Ein gesperrtes Konto nimmt Einzahlungen an, zahlt aber nicht aus")
    void gesperrt() {
    Konto konto = konto(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 = konto();
    konto.sperren();
    konto.entsperren();
    assertEquals(Kontostatus.AKTIV, konto.getStatus());
    }
    @Test
    @DisplayName("Kündigen geht nur bei leerem Konto")
    void kuendigen() {
    Konto konto = konto(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 = konto(Betrag.euro(100));
    Konto nach = konto();
    nach.kuendigen();
    assertThrows(IllegalStateException.class, () -> von.ueberweisen(nach, Betrag.euro(30)));
    assertEquals(Betrag.euro(100), von.getKontostand());
    }
    }
  2. Schreibe die Klasse Bank und eine Testklasse BankTest.

    Lösung
    BankTest.java
    package de.drv.bank;
    import static org.junit.jupiter.api.Assertions.assertEquals;
    import static org.junit.jupiter.api.Assertions.assertNull;
    import static org.junit.jupiter.api.Assertions.assertSame;
    import static org.junit.jupiter.api.Assertions.assertThrows;
    import java.time.LocalDate;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class BankTest {
    private final Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
    @Test
    @DisplayName("Monatsabschluss: jedes Konto reagiert auf seine Art")
    void monatsabschluss() {
    GiroKonto giro = new GiroKonto(anna, Betrag.euro(500));
    giro.einzahlen(Betrag.euro(100));
    SparKonto spar = new SparKonto(anna, 0.5);
    spar.einzahlen(Betrag.euro(2000));
    Bank bank = new Bank("Musterbank", 10);
    bank.aufnehmen(giro);
    bank.aufnehmen(spar);
    bank.monatsabschluss();
    assertEquals(Betrag.euro(95, 10), giro.getKontostand());
    assertEquals(Betrag.euro(2010), spar.getKontostand());
    }
    @Test
    @DisplayName("Der Gesamtbestand summiert alle Konten")
    void gesamtbestand() {
    GiroKonto giro = new GiroKonto(anna, Betrag.euro(500));
    giro.abheben(Betrag.euro(50));
    SparKonto spar = new SparKonto(anna, 0.5);
    spar.einzahlen(Betrag.euro(200));
    Bank bank = new Bank("Musterbank", 10);
    bank.aufnehmen(giro);
    bank.aufnehmen(spar);
    assertEquals(Betrag.euro(150), bank.getGesamtbestand());
    }
    @Test
    @DisplayName("Konten werden über ihre Nummer gefunden")
    void suche() {
    GiroKonto giro = new GiroKonto(anna, Betrag.NULL);
    Bank bank = new Bank("Musterbank", 10);
    bank.aufnehmen(giro);
    assertSame(giro, bank.suche(giro.getKontonummer()));
    assertNull(bank.suche(-1));
    }
    @Test
    @DisplayName("Eine volle Bank nimmt keine weiteren Konten auf")
    void voll() {
    Bank bank = new Bank("Musterbank", 1);
    bank.aufnehmen(new GiroKonto(anna, Betrag.NULL));
    assertThrows(IllegalStateException.class, () -> bank.aufnehmen(new GiroKonto(anna, Betrag.NULL)));
    }
    }
  3. Dispozinsen: Steht ein Girokonto beim Monatsabschluss im Minus, werden zusätzlich 1 % des negativen Betrags als Zinsen belastet. Erweitere monatsabschluss() im Girokonto und teste es.

    Lösung
    public static final double DISPOZINSSATZ = 1.0;
    @Override
    public void monatsabschluss() {
    belasten(KONTOFUEHRUNGSGEBUEHR);
    if (getKontostand().istNegativ()) {
    Betrag zinsen = getKontostand().prozent(DISPOZINSSATZ); // negativ
    belasten(Betrag.NULL.minus(zinsen)); // positiv belasten
    }
    }

    prozent liefert bei einem negativen Kontostand einen negativen Betrag – belasten erwartet aber einen positiven. Betrag.NULL.minus(zinsen) dreht das Vorzeichen um. Die Bank ändert sich dabei nicht – Polymorphie.

  4. Tagesgeldkonto: Lege eine neue Kontoart an – wie ein Sparkonto, aber der Zinssatz lässt sich ändern. Nimm es in die Bank auf. Was musst du an der Klasse Bank ändern?

    Lösung

    Nichts. Die Bank arbeitet nur mit Konto – jede neue Unterklasse, die getKontoart() und monatsabschluss() umsetzt, funktioniert sofort mit. Das ist der eigentliche Nutzen der Polymorphie.

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));
Kunde ben = new Kunde("Ben Beispiel", LocalDate.of(1999, 11, 2));
GiroKonto annasGiro = new GiroKonto(anna, Betrag.euro(500));
annasGiro.einzahlen(Betrag.euro(100));
SparKonto annasSparbuch = new SparKonto(anna, 0.5);
annasSparbuch.einzahlen(Betrag.euro(2000));
GiroKonto bensGiro = new GiroKonto(ben, Betrag.euro(200));
Bank bank = new Bank("Musterbank", 10);
bank.aufnehmen(annasGiro);
bank.aufnehmen(annasSparbuch);
bank.aufnehmen(bensGiro);
System.out.println(bank.uebersicht());
bank.monatsabschluss();
System.out.println();
System.out.println("Nach dem Monatsabschluss:");
System.out.println(bank.uebersicht());
Konto gefunden = bank.suche(1002);
if (gefunden instanceof SparKonto spar) {
System.out.println("Gefunden: " + spar);
}
}
}