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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- 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
finalvor dem Überschreiben schützen protectedgezielt einsetzen
Ausgangsstand für 15-bank
⤓ bank-abstrakt.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, GiroKonto.java, SparKonto.java, Bankdemo.java, BetragTest.java, BuchungTest.java, KontoTest.java, GiroKontoTest.java, SparKontoTest.java
Abstrakte Klassen
Abschnitt betitelt „Abstrakte Klassen“public abstract class Konto {
// … Felder, Konstruktor wie bisher
public abstract String getKontoart();
public abstract void monatsabschluss();
// … alle übrigen Methoden wie bisher}abstract classheiß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.
Die Kontoart
Abschnitt betitelt „Die Kontoart“Statt "Giro" + super.toString() – ein Kunstgriff aus dem letzten Kapitel –
fragt toString im Konto jetzt einfach die Kontoart ab:
@Overridepublic String toString() { return getKontoart() + " " + getKontokennung() + " (" + inhaber.getName() + ", " + status.getBezeichnung() + "): " + kontostand;}@Overridepublic 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.
Der Monatsabschluss
Abschnitt betitelt „Der Monatsabschluss“Am Monatsende geschieht bei jeder Kontoart etwas anderes: Das Girokonto zahlt eine Kontoführungsgebühr, das Sparkonto bekommt Zinsen.
public static final Betrag KONTOFUEHRUNGSGEBUEHR = Betrag.euro(4, 90);
@Overridepublic void monatsabschluss() { belasten(KONTOFUEHRUNGSGEBUEHR);}@Overridepublic void monatsabschluss() { zinsenGutschreiben();}Vereinfachung für unser Beispiel: Der Zinssatz gilt pro Monatsabschluss.
Ein Fall für protected
Abschnitt betitelt „Ein Fall für protected“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:
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.
Die Bank
Abschnitt betitelt „Die Bank“Jetzt kommt alles zusammen: Eine Bank verwaltet beliebige Konten – Giro- und
Sparkonten gemischt – in einem Array vom Typ Konto:
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).
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 €Polymorphie
Abschnitt betitelt „Polymorphie“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.
Und wenn man doch die genaue Art braucht?
Abschnitt betitelt „Und wenn man doch die genaue Art braucht?“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().
Regeln schützen mit final
Abschnitt betitelt „Regeln schützen mit final“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:
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.
Die Tests überstehen den Umbau
Abschnitt betitelt „Die Tests überstehen den Umbau“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:
/** 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.
Wenn es nicht klappt
Abschnitt betitelt „Wenn es nicht klappt“| 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 |
Übungen
Abschnitt betitelt „Übungen“-
Mache
Kontoabstrakt mitgetKontoart()undmonatsabschluss(). Setze beide inGiroKontoundSparKontoum. 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;}@Overridepublic String toString() {return getKontoart() + " " + getKontokennung() + " (" + inhaber.getName() + ", " + status.getBezeichnung() + "): "+ kontostand;}@Overridepublic boolean equals(Object obj) {if (this == obj) {return true;}if (!(obj instanceof Konto anderes)) {return false;}return kontonummer == anderes.kontonummer;}@Overridepublic 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;}@Overridepublic String getKontoart() {return "Girokonto";}@Overridepublic void monatsabschluss() {belasten(KONTOFUEHRUNGSGEBUEHR);}@Overridepublic Betrag getVerfuegbarerBetrag() {return getKontostand().plus(dispo);}@Overridepublic 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;}@Overridepublic String getKontoart() {return "Sparkonto";}@Overridepublic void monatsabschluss() {zinsenGutschreiben();}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, "%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());}} -
Schreibe die Klasse
Bankund eine TestklasseBankTest.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)));}} -
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;@Overridepublic void monatsabschluss() {belasten(KONTOFUEHRUNGSGEBUEHR);if (getKontostand().istNegativ()) {Betrag zinsen = getKontostand().prozent(DISPOZINSSATZ); // negativbelasten(Betrag.NULL.minus(zinsen)); // positiv belasten}}prozentliefert bei einem negativen Kontostand einen negativen Betrag –belastenerwartet aber einen positiven.Betrag.NULL.minus(zinsen)dreht das Vorzeichen um. Die Bank ändert sich dabei nicht – Polymorphie. -
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, diegetKontoart()undmonatsabschluss()umsetzt, funktioniert sofort mit. Das ist der eigentliche Nutzen der Polymorphie.
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)); 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); } }
}