Zum Inhalt springen

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.

  • 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 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, Bank.java, Bankdemo.java, BetragTest.java, BuchungTest.java, KontoTest.java, GiroKontoTest.java, SparKontoTest.java, BankTest.java

Verzinsbar.java
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 public und abstract; man schreibt beides nicht hin.
  • Ein Interface hat keine Instanzfelder und keinen Konstruktor. Ein new Verzinsbar() meldet Eclipse: Cannot instantiate the type Verzinsbar.
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;
}
@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 hat beide Methoden schon. Es muss nur noch sagen, dass es den Vertrag erfüllt:

SparKonto.java (Ausschnitt)
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 ─ ─ ─ ─ ─ ─ ─┘ Festgeld

Festgeld und Sparkonto haben keine gemeinsame Oberklasse (außer Object) – aber einen gemeinsamen Vertrag.

Zinslauf.java
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);
Terminal-Fenster
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.“

Betrag.java (Ausschnitte)
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));
Terminal-Fenster
[-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 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.

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
  1. Lege das Interface Verzinsbar und die Klasse Festgeld an. Lass SparKonto das 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;
    }
    @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);
    }
    }
  2. Schreibe den Zinslauf und 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));
    }
    }
  3. Lass Betrag das Interface Comparable<Betrag> umsetzen und teste das Sortieren mit Arrays.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. */
    @Override
    public int compareTo(Betrag anderer) {
    return Long.compare(cent, anderer.cent);
    }
    /** Deutsche Schreibweise, z. B. {@code 1.234,56 €}. */
    @Override
    public String toString() {
    long betrag = Math.abs(cent);
    return String.format(Locale.GERMANY, "%s%,d,%02d €", cent < 0 ? "-" : "", betrag / 100, betrag % 100);
    }
    }
  4. Kann ein Objekt gleichzeitig in der Bank (als Konto) und im Zinslauf (als Verzinsbar) vorkommen? Probiere es mit einem Sparkonto aus. Und ein Festgeld?

    Lösung

    Ein Sparkonto ja – es ist ein Konto und Verzinsbar. Beim Monatsabschluss der Bank und beim Zinslauf wird es dann übrigens zweimal verzinst: Die Bank ruft monatsabschluss() 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 kein Konto.

Lösung
Bankdemo.java
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));
}
}

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.