Zum Inhalt springen

Vererbung

Unsere Bank bekommt zwei neue Kontoarten: Ein Girokonto darf bis zu einem vereinbarten Dispo überzogen werden. Ein Sparkonto bringt Zinsen. Ansonsten können beide alles, was ein Konto kann – einzahlen, abheben, überweisen, sperren. Sollen wir die Klasse Konto zweimal kopieren und anpassen? Besser nicht: Jede Änderung müsste dann an drei Stellen gemacht werden.

  • eine Klasse von einer anderen erben lassen
  • den Konstruktor der Oberklasse mit super(…) aufrufen
  • geerbte Methoden überschreiben und mit super.methode() erweitern
  • erklären, was „ist ein“ bedeutet und wann Vererbung passt

Ausgangsstand für 15-bank

⤓ bank-vererbung.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, Bankdemo.java, BetragTest.java, BuchungTest.java, KontoTest.java

Ein Girokonto unterscheidet sich vom normalen Konto vor allem in einer Frage: Wie viel darf abgehoben werden? Beim Konto ist es der Kontostand, beim Girokonto der Kontostand plus Dispo. Wir geben dieser Frage im Konto eine eigene Methode – und lassen abheben sie benutzen:

Konto.java (Ausschnitte)
public Betrag getVerfuegbarerBetrag() {
return kontostand;
}
public boolean abheben(Betrag betrag) {
pruefePositiv(betrag);
// … Status prüfen
if (betrag.istGroesserAls(getVerfuegbarerBetrag())) {
return false;
}
kontostand = kontostand.minus(betrag);
return true;
}

Für das normale Konto ändert sich nichts – alle Tests bleiben grün. Aber eine Unterklasse kann jetzt genau diese eine Methode anders beantworten.

GiroKonto.java
package de.drv.bank;
public class GiroKonto extends Konto {
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 Betrag getVerfuegbarerBetrag() {
return getKontostand().plus(dispo);
}
@Override
public String toString() {
return "Giro" + super.toString() + ", Dispo " + dispo;
}
}

GiroKonto extends Konto heißt: Ein GiroKonto ist ein Konto – mit allem, was dazugehört. Es erbt alle Felder und Methoden. einzahlen, abheben, ueberweisen, sperren – nichts davon steht in GiroKonto, und trotzdem kann ein Girokonto all das.

Begriff hier
Oberklasse (auch Basisklasse) Konto
Unterklasse (auch abgeleitete Klasse) GiroKonto
erben GiroKonto bekommt alles von Konto
erweitern GiroKonto fügt hinzu: dispo, getDispo()
überschreiben GiroKonto ersetzt: getVerfuegbarerBetrag(), toString()

Eine Klasse kann in Java nur von einer Klasse erben.

Konstruktoren werden nicht vererbt. Ein GiroKonto braucht einen eigenen – aber der Teil, der ein Konto einrichtet (Nummer vergeben, Inhaber prüfen, Status setzen), steht schon im Konstruktor von Konto. super(inhaber) ruft ihn auf.

  • super(…) muss bei unserem Sprachstand die erste Anweisung im Konstruktor sein.
  • Fehlt der Aufruf, versucht Java, einen Konstruktor ohne Parameter aufzurufen. Den hat Konto nicht – Eclipse meldet: Implicit super constructor Konto() is undefined. Must explicitly invoke another constructor.

getVerfuegbarerBetrag() im Girokonto ersetzt die Methode aus Konto. Und jetzt passiert etwas Bemerkenswertes: abheben steht nur in Konto und wurde nicht angefasst – aber wenn es auf einem Girokonto aufgerufen wird, ruft es getVerfuegbarerBetrag() des Girokontos auf. Java entscheidet erst beim Ausführen, welche Fassung einer Methode läuft – anhand des tatsächlichen Objekts.

  • Die Methode im Girokonto braucht dieselbe Signatur – Name, Parameter, Rückgabetyp.
  • Sie darf nicht weniger sichtbar sein: Aus public darf kein private werden (Cannot reduce the visibility of the inherited method from Konto).
  • @Override gehört immer dazu – siehe Kapitel toString, equals und Records.

toString() im Girokonto soll das bisherige toString() nicht ersetzen, sondern ergänzen. Mit super.toString() ruft es die Fassung der Oberklasse auf und hängt den Dispo an:

Terminal-Fenster
GiroKonto 12345678/1001 (Anna Muster, aktiv): -200,00 €, Dispo 500,00 €

GiroKonto erbt das Feld kontostand – darf aber nicht direkt darauf zugreifen. Es ist private, und private heißt: nur die Klasse Konto selbst (The field Konto.kontostand is not visible). Das Girokonto benutzt deshalb getKontostand().

Genau dafür gibt es die Stufe protected: sichtbar für Unterklassen (und das Package). Wir brauchen sie hier nicht – und das ist gut so. Ein protected-Feld könnte jede Unterklasse beliebig ändern, und die Regeln des Kontos wären wieder umgehbar. Die Faustregel bleibt: Felder private.

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;
}
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, "Spar%s, Zinssatz %.2f %%", super.toString(), zinssatz);
}
}

Das Sparkonto überschreibt getVerfuegbarerBetrag() nicht – es kann also, wie das normale Konto, nicht überzogen werden. Dafür erweitert es das Konto um eine neue Methode: zinsenGutschreiben().

Für die Zinsen hat Betrag eine neue Methode bekommen:

Betrag.java (Ausschnitt)
/** Der angegebene Prozentsatz dieses Betrags, kaufmännisch auf ganze Cent gerundet. */
public Betrag prozent(double prozentsatz) {
return new Betrag(Math.round(cent * prozentsatz / 100));
}

Gerechnet wird mit double – aber das Ergebnis wird sofort auf ganze Cent gerundet. 1,5 % von 333,33 € sind 4,99995 € – gutgeschrieben werden 5,00 €.

Konto konto = new GiroKonto(anna, Betrag.euro(500));
konto.abheben(Betrag.euro(50)); // erlaubt: Dispo
System.out.println(konto.getVerfuegbarerBetrag()); // 450,00 €

Eine Variable vom Typ Konto kann auf ein GiroKonto zeigen – denn ein Girokonto ist ein Konto. Aufgerufen wird trotzdem die Methode des Objekts: getVerfuegbarerBetrag() des Girokontos, mit Dispo.

Umgekehrt geht es nicht: Über eine Konto-Variable kann man nur Methoden aufrufen, die Konto kennt. konto.zinsenGutschreiben() meldet The method zinsenGutschreiben() is undefined for the type Konto – auch wenn das Objekt ein Sparkonto wäre. Was sich daraus machen lässt, ist Thema des nächsten Kapitels.

Jetzt ergibt auch das Kapitel über toString und equals ein vollständiges Bild: Eine Klasse ohne extends erbt automatisch von Object.

Object
└── Konto
├── GiroKonto
└── SparKonto

Deshalb hat jedes Objekt ein toString, ein equals, ein hashCode. Konto überschreibt sie, GiroKonto und SparKonto erben die Fassungen von Konto – und überschreiben toString noch einmal. Und equals über die Kontonummer gilt automatisch auch für Giro- und Sparkonten.

Vererbung passt, wenn die Unterklasse wirklich ein Spezialfall der Oberklasse ist – „ein Girokonto ist ein Konto“ – und sich überall so verhalten kann, wo ein Konto erwartet wird.

Sie passt nicht, nur weil zwei Klassen ähnliche Felder haben. Ein Kunde hat einen Namen, eine Bank auch – trotzdem ist eine Bank kein Kunde. Und Records und final-Klassen lassen sich gar nicht erweitern: The record Betrag cannot be the superclass of X; a record is final and cannot be extended.

Meldung in Eclipse Ursache
Implicit super constructor Konto() is undefined … super(…) im Konstruktor fehlt
The Java feature ‘Flexible Constructor Bodies’ is only available with source level 25 … super(…) ist nicht die erste Anweisung
The field Konto.kontostand is not visible Zugriff auf ein private-Feld der Oberklasse – Getter benutzen
Cannot reduce the visibility of the inherited method from Konto Überschreibende Methode ist weniger sichtbar
The method … is undefined for the type Konto Methode der Unterklasse über eine Konto-Variable aufgerufen
… a record is final and cannot be extended Ein Record (oder eine final-Klasse) als Oberklasse
  1. Ergänze getVerfuegbarerBetrag() im Konto und lass abheben sie benutzen. Laufen alle bisherigen Tests noch?

  2. Schreibe GiroKonto und eine Testklasse GiroKontoTest: Abheben bis zum Dispo, nicht darüber hinaus, verfügbarer Betrag, Überweisung mit Dispo.

    Lösung
    GiroKonto.java
    package de.drv.bank;
    public class GiroKonto extends Konto {
    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 Betrag getVerfuegbarerBetrag() {
    return getKontostand().plus(dispo);
    }
    @Override
    public String toString() {
    return "Giro" + super.toString() + ", Dispo " + dispo;
    }
    }
    Lösung
    GiroKontoTest.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.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 GiroKontoTest {
    private final Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
    @Test
    @DisplayName("Abheben bis zum Dispo ist erlaubt")
    void bisZumDispo() {
    GiroKonto giro = new GiroKonto(anna, Betrag.euro(500));
    giro.einzahlen(Betrag.euro(100));
    assertTrue(giro.abheben(Betrag.euro(600)));
    assertEquals(Betrag.euro(-500), giro.getKontostand());
    }
    @Test
    @DisplayName("Über den Dispo hinaus geht nichts")
    void ueberDenDispo() {
    GiroKonto giro = new GiroKonto(anna, Betrag.euro(500));
    assertFalse(giro.abheben(Betrag.euro(500, 1)));
    assertEquals(Betrag.NULL, giro.getKontostand());
    }
    @Test
    @DisplayName("Verfügbar ist Kontostand plus Dispo")
    void verfuegbar() {
    GiroKonto giro = new GiroKonto(anna, Betrag.euro(500));
    giro.einzahlen(Betrag.euro(20));
    assertEquals(Betrag.euro(520), giro.getVerfuegbarerBetrag());
    }
    @Test
    @DisplayName("Auch eine Überweisung darf den Dispo nutzen")
    void ueberweisenMitDispo() {
    GiroKonto giro = new GiroKonto(anna, Betrag.euro(500));
    Konto ziel = new Konto(anna);
    assertTrue(giro.ueberweisen(ziel, Betrag.euro(200)));
    assertEquals(Betrag.euro(-200), giro.getKontostand());
    assertEquals(Betrag.euro(200), ziel.getKontostand());
    }
    @Test
    @DisplayName("Ein Girokonto ist ein Konto")
    void istEinKonto() {
    Konto konto = new GiroKonto(anna, Betrag.euro(100));
    assertTrue(konto.abheben(Betrag.euro(50)));
    assertEquals(Betrag.euro(50), konto.getVerfuegbarerBetrag());
    }
    @Test
    @DisplayName("Ein negativer Dispo wird abgelehnt")
    void negativerDispo() {
    assertThrows(IllegalArgumentException.class, () -> new GiroKonto(anna, Betrag.euro(-1)));
    }
    }
  3. Ergänze Betrag um prozent(double) und schreibe SparKonto mit Test.

    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;
    }
    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, "Spar%s, Zinssatz %.2f %%", super.toString(), zinssatz);
    }
    }
    Lösung
    SparKontoTest.java
    package de.drv.bank;
    import static org.junit.jupiter.api.Assertions.assertEquals;
    import static org.junit.jupiter.api.Assertions.assertFalse;
    import java.time.LocalDate;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class SparKontoTest {
    private final Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
    @Test
    @DisplayName("Zinsen werden gutgeschrieben")
    void zinsen() {
    SparKonto spar = new SparKonto(anna, 1.5);
    spar.einzahlen(Betrag.euro(1000));
    assertEquals(Betrag.euro(15), spar.zinsenGutschreiben());
    assertEquals(Betrag.euro(1015), spar.getKontostand());
    }
    @Test
    @DisplayName("Ohne Guthaben keine Zinsen")
    void keineZinsen() {
    SparKonto spar = new SparKonto(anna, 1.5);
    assertEquals(Betrag.NULL, spar.zinsenGutschreiben());
    assertEquals(Betrag.NULL, spar.getKontostand());
    }
    @Test
    @DisplayName("Ein Sparkonto kann nicht überzogen werden")
    void keinUeberziehen() {
    SparKonto spar = new SparKonto(anna, 1.5);
    spar.einzahlen(Betrag.euro(100));
    assertFalse(spar.abheben(Betrag.euro(100, 1)));
    assertEquals(Betrag.euro(100), spar.getKontostand());
    }
    }
  4. Kann ein gesperrtes Girokonto überzogen werden? Überlege erst, dann teste es.

    Lösung

    Nein. abheben steht in Konto und prüft zuerst den Status – ein gesperrtes Konto zahlt nichts aus, egal welcher Art. Diese Regel hat das Girokonto geerbt, ohne dass eine Zeile dafür geschrieben werden musste.

  5. Überlege: Sollte ein Depotkonto – ein Konto für Wertpapiere – auch von Konto erben? Was spricht dafür, was dagegen?

    Lösung

    Dafür: Es hat einen Inhaber, eine Nummer, kann gesperrt werden. Dagegen: Es enthält Wertpapiere, kein Geld. einzahlen(Betrag), abheben(Betrag) oder ein Kontostand in Euro passen nicht. Ein Depot würde sich also nicht überall so verhalten können, wo ein Konto erwartet wird – ein deutliches Zeichen, dass Vererbung hier die falsche Wahl wäre. Diese Frage kommt in der zweiten Woche wieder, wenn es um den Entwurf von Klassen geht.

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));
GiroKonto giro = new GiroKonto(anna, Betrag.euro(500));
giro.einzahlen(Betrag.euro(100));
System.out.println("300 € abheben: " + giro.abheben(Betrag.euro(300)));
System.out.println(giro);
System.out.println("Verfügbar: " + giro.getVerfuegbarerBetrag());
SparKonto spar = new SparKonto(anna, 1.5);
spar.einzahlen(Betrag.euro(1000));
System.out.println("Zinsen: " + spar.zinsenGutschreiben());
System.out.println("1.300 € vom Sparkonto abheben: " + spar.abheben(Betrag.euro(1300)));
System.out.println(spar);
Konto konto = giro;
System.out.println("Als Konto verfügbar: " + konto.getVerfuegbarerBetrag());
}
}