Interfaces
Unsere Bank bietet ein neues Produkt an: Festgeld. Man legt einen Betrag an, bekommt Zinsen – kann aber nichts abheben, nichts einzahlen, nichts überweisen. Ist Festgeld ein Konto? Nach dem, was wir über Vererbung gesagt haben: nein. Ein Festgeld könnte sich nicht überall wie ein Konto verhalten.
Trotzdem hat es etwas mit dem Sparkonto gemeinsam: Beide werden verzinst. Und ein Zinslauf am Jahresende soll beide gleich behandeln. Wie geht das ohne gemeinsame Oberklasse? Mit einem Interface.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- ein Interface schreiben und in mehreren Klassen umsetzen
- ein Interface als Typ benutzen – für Variablen, Parameter und Arrays
- ein Interface der Standardbibliothek umsetzen:
Comparable - entscheiden, wann eine abstrakte Klasse und wann ein Interface passt
Ausgangsstand für 15-bank
⤓ bank-interfaces.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, Bank.java, Bankdemo.java, BetragTest.java, BuchungTest.java, KontoTest.java, GiroKontoTest.java, SparKontoTest.java, BankTest.java
Ein Interface ist ein Vertrag
Abschnitt betitelt „Ein Interface ist ein Vertrag“package de.drv.bank;
public interface Verzinsbar {
double getZinssatz();
Betrag zinsenGutschreiben();
}Ein Interface beschreibt, was etwas kann – nicht wie. Es ist ein
Vertrag: Wer Verzinsbar ist, hat einen Zinssatz und kann Zinsen gutschreiben.
- Die Methoden haben keinen Rumpf – wie abstrakte Methoden.
- Sie sind automatisch
publicundabstract; man schreibt beides nicht hin. - Ein Interface hat keine Instanzfelder und keinen Konstruktor. Ein
new Verzinsbar()meldet Eclipse: Cannot instantiate the type Verzinsbar.
Das Festgeld setzt den Vertrag um
Abschnitt betitelt „Das Festgeld setzt den Vertrag um“package de.drv.bank;
import java.util.Locale;
public class Festgeld implements Verzinsbar {
private final Kunde inhaber; private final double zinssatz; private Betrag guthaben;
public Festgeld(Kunde inhaber, Betrag anlage, double zinssatz) { if (inhaber == null) { throw new IllegalArgumentException("Festgeld braucht einen Inhaber."); } if (anlage == null || !anlage.istGroesserAls(Betrag.NULL)) { throw new IllegalArgumentException("Die Anlage muss größer als 0 sein: " + anlage); } if (zinssatz < 0) { throw new IllegalArgumentException("Der Zinssatz darf nicht negativ sein: " + zinssatz); } this.inhaber = inhaber; this.guthaben = anlage; this.zinssatz = zinssatz; }
public Kunde getInhaber() { return inhaber; }
public Betrag getGuthaben() { return guthaben; }
@Override public double getZinssatz() { return zinssatz; }
@Override public Betrag zinsenGutschreiben() { Betrag zinsen = guthaben.prozent(zinssatz); guthaben = guthaben.plus(zinsen); return zinsen; }
@Override public String toString() { return String.format(Locale.GERMANY, "Festgeld (%s): %s, Zinssatz %.2f %%", inhaber.getName(), guthaben, zinssatz); }
}implements Verzinsbar heißt: Diese Klasse erfüllt den Vertrag. Sie
muss jetzt jede Methode des Interfaces umsetzen – sonst meldet Eclipse: The
type Festgeld must implement the inherited abstract method
Verzinsbar.zinsenGutschreiben(). @Override steht auch hier davor.
Das Sparkonto auch
Abschnitt betitelt „Das Sparkonto auch“Das Sparkonto hat beide Methoden schon. Es muss nur noch sagen, dass es den Vertrag erfüllt:
public class SparKonto extends Konto implements Verzinsbar {Eine Klasse kann von einer Klasse erben und beliebig viele Interfaces umsetzen. Das Sparkonto ist ein Konto – und es ist verzinsbar.
Konto (abstrakt) «interface» Verzinsbar ┌──────┴──────┐ ┌──────┴──────┐ GiroKonto SparKonto ─ ─ ─ ─ ─ ─ ─┘ FestgeldFestgeld und Sparkonto haben keine gemeinsame Oberklasse (außer Object) –
aber einen gemeinsamen Vertrag.
Das Interface als Typ
Abschnitt betitelt „Das Interface als Typ“package de.drv.bank;
public class Zinslauf {
public static Betrag durchfuehren(Verzinsbar[] anlagen) { Betrag summe = Betrag.NULL; for (Verzinsbar anlage : anlagen) { summe = summe.plus(anlage.zinsenGutschreiben()); } return summe; }
}Verzinsbar[] anlagen = {sparbuch, festgeld};Betrag zinsen = Zinslauf.durchfuehren(anlagen);Sparkonto 12345678/1001 (Anna Muster, aktiv): 2.010,00 €, Zinssatz 0,50 %Festgeld (Anna Muster): 10.200,00 €, Zinssatz 2,00 %Zinsen insgesamt: 210,00 €Ein Interface ist ein vollwertiger Typ: für Variablen, Parameter, Arrays.
Ein Verzinsbar[] nimmt jedes Objekt auf, dessen Klasse Verzinsbar umsetzt.
Der Zinslauf kennt weder Sparkonten noch Festgeld – nur den Vertrag. Das ist
Polymorphie über ein Interface, genau wie beim Monatsabschluss über die
abstrakte Klasse.
Und wie dort gilt: Über eine Verzinsbar-Variable lassen sich nur die Methoden
des Interfaces aufrufen. anlage.einzahlen(…) meldet The method
einzahlen(Betrag) is undefined for the type Verzinsbar – auch wenn das Objekt
ein Sparkonto ist.
Ein Interface aus der Standardbibliothek: Comparable
Abschnitt betitelt „Ein Interface aus der Standardbibliothek: Comparable“Arrays.sort kann int-Arrays sortieren, String-Arrays auch. Aber woher
soll es wissen, wie man Beträge sortiert? Die Antwort ist ein Interface aus
der Standardbibliothek: Comparable. Wer es umsetzt, sagt: „Meine Objekte
haben eine natürliche Reihenfolge – und so vergleicht man sie.“
public record Betrag(long cent) implements Comparable<Betrag> {
// …
@Override public int compareTo(Betrag anderer) { return Long.compare(cent, anderer.cent); }
}compareTo liefert eine Zahl:
| Ergebnis | bedeutet |
|---|---|
| negativ | dieser Betrag ist kleiner als der andere |
0 |
beide sind gleich groß |
| positiv | dieser Betrag ist größer |
Long.compare erledigt genau das für zwei long-Werte. Und schon funktioniert:
Betrag[] betraege = {Betrag.euro(10), Betrag.euro(-3), Betrag.euro(0, 50)};Arrays.sort(betraege);System.out.println(Arrays.toString(betraege));[-3,00 €, 0,50 €, 10,00 €]Arrays.sort kennt Betrag nicht – aber es kennt den Vertrag Comparable. Das
ist die Stärke von Interfaces: Code, der lange vor unserer Klasse geschrieben
wurde, arbeitet mit ihr zusammen.
Abstrakte Klasse oder Interface?
Abschnitt betitelt „Abstrakte Klasse oder Interface?“| abstrakte Klasse | Interface | |
|---|---|---|
| beschreibt | was etwas ist – „ist ein Konto“ | was etwas kann – „ist verzinsbar“ |
| Felder | ja | nur Konstanten |
| Konstruktor | ja | nein |
| fertige Methoden | ja | nur als default-Methoden (siehe unten) |
| eine Klasse kann … | von einer erben (extends) |
viele umsetzen (implements) |
| Beispiel | Konto |
Verzinsbar, Comparable |
Faustregel: Teilen Klassen Daten und Verhalten, weil sie Spezialfälle derselben Sache sind – abstrakte Klasse. Haben ganz verschiedene Klassen eine gemeinsame Fähigkeit – Interface.
Wenn es nicht klappt
Abschnitt betitelt „Wenn es nicht klappt“| Meldung in Eclipse | Ursache |
|---|---|
| The type … must implement the inherited abstract method … | Eine Methode des Interfaces fehlt |
| Cannot instantiate the type Verzinsbar | new bei einem Interface |
| Cannot reduce the visibility of the inherited method from Verzinsbar | public vor der umgesetzten Methode vergessen |
| … cannot be the superclass of X; a superclass must be a class | extends statt implements bei einem Interface |
| … cannot be a superinterface of X; a superinterface must be an interface | implements statt extends bei einer Klasse |
| The method … is undefined for the type Verzinsbar | Methode aufgerufen, die nicht im Interface steht |
Übungen
Abschnitt betitelt „Übungen“-
Lege das Interface
Verzinsbarund die KlasseFestgeldan. LassSparKontodas Interface umsetzen.Lösung
Festgeld.java package de.drv.bank;import java.util.Locale;public class Festgeld implements Verzinsbar {private final Kunde inhaber;private final double zinssatz;private Betrag guthaben;public Festgeld(Kunde inhaber, Betrag anlage, double zinssatz) {if (inhaber == null) {throw new IllegalArgumentException("Festgeld braucht einen Inhaber.");}if (anlage == null || !anlage.istGroesserAls(Betrag.NULL)) {throw new IllegalArgumentException("Die Anlage muss größer als 0 sein: " + anlage);}if (zinssatz < 0) {throw new IllegalArgumentException("Der Zinssatz darf nicht negativ sein: " + zinssatz);}this.inhaber = inhaber;this.guthaben = anlage;this.zinssatz = zinssatz;}public Kunde getInhaber() {return inhaber;}public Betrag getGuthaben() {return guthaben;}@Overridepublic double getZinssatz() {return zinssatz;}@Overridepublic Betrag zinsenGutschreiben() {Betrag zinsen = guthaben.prozent(zinssatz);guthaben = guthaben.plus(zinsen);return zinsen;}@Overridepublic String toString() {return String.format(Locale.GERMANY, "Festgeld (%s): %s, Zinssatz %.2f %%",inhaber.getName(), guthaben, zinssatz);}} -
Schreibe den
Zinslaufund einen Test, der Sparkonto und Festgeld gemeinsam verzinst.Lösung
ZinslaufTest.java package de.drv.bank;import static org.junit.jupiter.api.Assertions.assertEquals;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 ZinslaufTest {private final Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));@Test@DisplayName("Festgeld wird verzinst")void festgeld() {Festgeld festgeld = new Festgeld(anna, Betrag.euro(10_000), 2.0);assertEquals(Betrag.euro(200), festgeld.zinsenGutschreiben());assertEquals(Betrag.euro(10_200), festgeld.getGuthaben());}@Test@DisplayName("Der Zinslauf verzinst Sparkonten und Festgeld gleichermaßen")void zinslauf() {SparKonto spar = new SparKonto(anna, 0.5);spar.einzahlen(Betrag.euro(2000));Festgeld festgeld = new Festgeld(anna, Betrag.euro(10_000), 2.0);Verzinsbar[] anlagen = {spar, festgeld};assertEquals(Betrag.euro(210), Zinslauf.durchfuehren(anlagen));assertEquals(Betrag.euro(2010), spar.getKontostand());assertEquals(Betrag.euro(10_200), festgeld.getGuthaben());}@Test@DisplayName("Festgeld ohne Anlage wird abgelehnt")void ohneAnlage() {assertThrows(IllegalArgumentException.class, () -> new Festgeld(anna, Betrag.NULL, 2.0));}} -
Lass
Betragdas InterfaceComparable<Betrag>umsetzen und teste das Sortieren mitArrays.sort.Lösung
Betrag.java package de.drv.bank;import java.util.Locale;/*** Ein Geldbetrag in Euro, intern exakt in Cent gespeichert.** Ein Betrag ist unveränderlich: Rechenmethoden liefern immer einen neuen Betrag.** @param cent der Betrag in Cent – 1,00 € sind 100 Cent, {@code new Betrag(500)} sind 5,00 €*/public record Betrag(long cent) implements Comparable<Betrag> {/** Der Betrag 0,00 € – also 0 Cent. */public static final Betrag NULL = new Betrag(0);/** Ein Betrag in ganzen Euro, z. B. {@code Betrag.euro(250)}. */public static Betrag euro(long euro) {return new Betrag(euro * 100);}/** Ein Betrag aus Euro und Cent, z. B. {@code Betrag.euro(19, 99)}. */public static Betrag euro(long euro, int cent) {if (cent < 0 || cent > 99) {throw new IllegalArgumentException("Cent muss zwischen 0 und 99 liegen: " + cent);}return new Betrag(euro * 100 + (euro < 0 ? -cent : cent));}/** Summe dieses und des anderen Betrags. */public Betrag plus(Betrag anderer) {return new Betrag(cent + anderer.cent);}/** Differenz dieses und des anderen Betrags. */public Betrag minus(Betrag anderer) {return new Betrag(cent - anderer.cent);}/** Der angegebene Prozentsatz dieses Betrags, kaufmännisch auf ganze Cent gerundet. */public Betrag prozent(double prozentsatz) {return new Betrag(Math.round(cent * prozentsatz / 100));}/** {@code true}, wenn der Betrag kleiner als 0 ist. */public boolean istNegativ() {return cent < 0;}/** {@code true}, wenn dieser Betrag größer als der andere ist. */public boolean istGroesserAls(Betrag anderer) {return cent > anderer.cent;}/** {@code true}, wenn dieser Betrag kleiner als der andere ist. */public boolean istKleinerAls(Betrag anderer) {return cent < anderer.cent;}/** Vergleich nach der Höhe: negativ, wenn dieser Betrag kleiner ist, 0 bei Gleichheit, sonst positiv. */@Overridepublic int compareTo(Betrag anderer) {return Long.compare(cent, anderer.cent);}/** Deutsche Schreibweise, z. B. {@code 1.234,56 €}. */@Overridepublic String toString() {long betrag = Math.abs(cent);return String.format(Locale.GERMANY, "%s%,d,%02d €", cent < 0 ? "-" : "", betrag / 100, betrag % 100);}} -
Kann ein Objekt gleichzeitig in der
Bank(alsKonto) und imZinslauf(alsVerzinsbar) vorkommen? Probiere es mit einem Sparkonto aus. Und ein Festgeld?Lösung
Ein Sparkonto ja – es ist ein
KontoundVerzinsbar. Beim Monatsabschluss der Bank und beim Zinslauf wird es dann übrigens zweimal verzinst: Die Bank ruftmonatsabschluss()auf, und der verzinst bereits. Ein Hinweis, dass die beiden Abläufe in einem echten System aufeinander abgestimmt werden müssten.Ein Festgeld passt nur in den Zinslauf:
bank.aufnehmen(festgeld)meldet Eclipse als Fehler, denn ein Festgeld ist keinKonto.
Lösung
package de.drv.bank;
import java.time.LocalDate;import java.util.Arrays;
public class Bankdemo {
public static void main(String[] args) { Kunde anna = new Kunde("Anna Muster", LocalDate.of(2004, 3, 12));
SparKonto sparbuch = new SparKonto(anna, 0.5); sparbuch.einzahlen(Betrag.euro(2000)); Festgeld festgeld = new Festgeld(anna, Betrag.euro(10_000), 2.0);
Verzinsbar[] anlagen = {sparbuch, festgeld}; Betrag zinsen = Zinslauf.durchfuehren(anlagen);
System.out.println(sparbuch); System.out.println(festgeld); System.out.println("Zinsen insgesamt: " + zinsen);
Betrag[] betraege = {Betrag.euro(10), Betrag.euro(-3), Betrag.euro(0, 50)}; Arrays.sort(betraege); System.out.println(Arrays.toString(betraege)); }
}Ausblick
Abschnitt betitelt „Ausblick“Interfaces begegnen dir ab jetzt überall – in der Standardbibliothek und in unserem eigenen Projekt: Im nächsten Wordle-Teil trennt ein Interface das Spiel von der Konsole.