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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- 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 herunterladenWer 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
Eine Vorbereitung im Konto
Abschnitt betitelt „Eine Vorbereitung im Konto“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:
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.
Das Girokonto
Abschnitt betitelt „Das Girokonto“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; }
}extends
Abschnitt betitelt „extends“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.
super(…) im Konstruktor
Abschnitt betitelt „super(…) im Konstruktor“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
Kontonicht – Eclipse meldet: Implicit super constructor Konto() is undefined. Must explicitly invoke another constructor.
Überschreiben
Abschnitt betitelt „Überschreiben“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
publicdarf keinprivatewerden (Cannot reduce the visibility of the inherited method from Konto). @Overridegehört immer dazu – siehe Kapitel toString, equals und Records.
super.methode()
Abschnitt betitelt „super.methode()“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:
GiroKonto 12345678/1001 (Anna Muster, aktiv): -200,00 €, Dispo 500,00 €Und der private Kontostand?
Abschnitt betitelt „Und der private Kontostand?“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.
Das Sparkonto
Abschnitt betitelt „Das Sparkonto“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:
/** 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 €.
Ein Girokonto ist ein Konto
Abschnitt betitelt „Ein Girokonto ist ein Konto“Konto konto = new GiroKonto(anna, Betrag.euro(500));konto.abheben(Betrag.euro(50)); // erlaubt: DispoSystem.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.
Alles erbt von Object
Abschnitt betitelt „Alles erbt von Object“Jetzt ergibt auch das Kapitel über toString und equals ein vollständiges
Bild: Eine Klasse ohne extends erbt automatisch von Object.
Object └── Konto ├── GiroKonto └── SparKontoDeshalb 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.
Wann passt Vererbung?
Abschnitt betitelt „Wann passt Vererbung?“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.
Wenn es nicht klappt
Abschnitt betitelt „Wenn es nicht klappt“| 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 |
Übungen
Abschnitt betitelt „Übungen“-
Ergänze
getVerfuegbarerBetrag()im Konto und lassabhebensie benutzen. Laufen alle bisherigen Tests noch? -
Schreibe
GiroKontound eine TestklasseGiroKontoTest: 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;}@Overridepublic Betrag getVerfuegbarerBetrag() {return getKontostand().plus(dispo);}@Overridepublic 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)));}} -
Ergänze
Betragumprozent(double)und schreibeSparKontomit 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;}@Overridepublic 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());}} -
Kann ein gesperrtes Girokonto überzogen werden? Überlege erst, dann teste es.
Lösung
Nein.
abhebensteht inKontound 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. -
Überlege: Sollte ein Depotkonto – ein Konto für Wertpapiere – auch von
Kontoerben? 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
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()); }
}