Zum Inhalt springen

Kapselung

Am Ende des letzten Kapitels stand plötzlich eine Million Euro auf dem Konto – ohne jede Einzahlung, einfach durch direkten Zugriff auf das Feld. Kapselung heißt: Ein Objekt schützt seine Daten. Von außen kommt man nur über die Methoden heran, die das Objekt anbietet – und die halten sich an die Regeln.

  • Felder mit private vor dem Zugriff von außen schützen
  • Getter schreiben – und begründen, wann ein Setter sinnvoll ist
  • Regeln im Konstruktor und in Methoden durchsetzen
  • Felder mit final unveränderlich machen
  • die vier Sichtbarkeiten von Java unterscheiden

Ausgangsstand für 15-bank

⤓ bank-kapselung.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, Kunde.java, Konto.java, Bankdemo.java, BetragTest.java

Java kennt vier Stufen, wer ein Feld, eine Methode oder einen Konstruktor benutzen darf:

Schlüsselwort sichtbar für
private nur die eigene Klasse
(keins) alle Klassen im selben Package – deshalb funktionierte die Hintertür
protected Package und Unterklassen – dazu mehr bei der Vererbung
public alle

Jede Stufe erweitert die vorherige: private → keine Angabe → protected → public. Kombinieren lassen sich die Schlüsselwörter nicht – ein private protected lehnt Eclipse ab (The field … can only set one of public / protected / private).

Als Bild: ein Haus mit einem Arbeitszimmer, in dem ein privater Kühlschrank steht.

Sichtbarkeiten in Java als HausDas Haus ist das Package de.drv.bank. Im Arbeitszimmer, der Klasse Konto, steht ein Kühlschrank: das private Feld kontostand. Nur die Klasse selbst darf hineinsehen. Die Mitbewohner im selben Haus, andere Klassen im Package, dürfen auf alles ohne Angabe und auf protected zugreifen. Die Tochter wohnt in einem anderen Haus, sie ist eine Unterklasse in einem anderen Package, und darf auf protected und public zugreifen. Passanten auf der Straße, alle anderen Klassen, sehen nur public.Straße – alle anderen Klassen, irgendwoHaus = Package de.drv.bankArbeitszimmerKlasse KontoKühlschrank:kontostandichprivateWohnzimmerKlasse BankdemoMitbewohnerPackageprotectedKücheKlasse KundeMitbewohnerPackageprotectedanderes PackageZimmer der Tochter… extends KontoprotectedPassantpublic
private – nur ich, im eigenen Zimmerkeine Angabe – alle, die im Haus wohnenprotected – alle im Haus und die Tochter, auch nach dem Auszugpublic – jeder, der vorbeikommtWer eine engere Stufe öffnen darf, darf auch alle offeneren – ich also alles, die Tochter auch public. Die Mitbewohner tragen zwei Abzeichen, weil hier die Besonderheit von Java steckt: protected gilt nicht nur für die Tochter, sondern auch für alle im Haus.

Die Faustregel für den Anfang:

  • Felder sind private.
  • Methoden und Konstruktoren, die andere benutzen sollen, sind public.
  • Hilfsmethoden, die nur intern gebraucht werden, sind private.
Konto.java
package de.drv.bank;
import java.time.LocalDate;
public 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;
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;
}
public Konto(Kunde inhaber, Betrag startguthaben) {
this(inhaber);
einzahlen(startguthaben);
}
public int getKontonummer() {
return kontonummer;
}
public Kunde getInhaber() {
return inhaber;
}
public LocalDate getEroeffnetAm() {
return eroeffnetAm;
}
public Betrag getKontostand() {
return kontostand;
}
public void einzahlen(Betrag betrag) {
pruefePositiv(betrag);
kontostand = kontostand.plus(betrag);
}
public boolean abheben(Betrag betrag) {
pruefePositiv(betrag);
if (betrag.istGroesserAls(kontostand)) {
return false;
}
kontostand = kontostand.minus(betrag);
return true;
}
public boolean ueberweisen(Konto ziel, Betrag betrag) {
if (!abheben(betrag)) {
return false;
}
ziel.einzahlen(betrag);
return true;
}
public String getKontokennung() {
return BANKLEITZAHL + "/" + kontonummer;
}
public String beschreibung() {
return "Konto " + getKontokennung() + " (" + inhaber.getName() + "): " + kontostand;
}
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);
}
}
}

Was sich geändert hat:

Alle Felder sind private. Die Hintertür aus dem letzten Kapitel meldet jetzt in Eclipse: The field Konto.kontostand is not visible. Der Kontostand lässt sich nur noch über einzahlen, abheben und ueberweisen ändern – und die prüfen die Regeln.

Auch der Zähler für die Kontonummern ist jetzt private. Vorher hätte jeder Konto.anzahlKonten = 0; setzen können – und das nächste Konto hätte eine Nummer bekommen, die es schon gibt.

Damit man den Kontostand trotzdem lesen kann, gibt es Getter: öffentliche Methoden, die den Wert eines Felds zurückgeben. Nach Konvention heißen sie get + Feldname mit großem Anfangsbuchstaben: getKontostand(). Bei boolean-Werten ist auch is… üblich, etwa isGesperrt().

Es gibt kein setKontostand und kein setKontonummer. Ein Setter, der den Kontostand auf jeden beliebigen Wert setzt, wäre nur eine Hintertür mit Türschild. Eclipse kann auf Knopfdruck zu jedem Feld Getter und Setter erzeugen (Source → Generate Getters and Setters…) – erzeuge trotzdem nur, was fachlich gebraucht wird.

  • einzahlen und abheben lehnen Beträge ab, die nicht größer als 0 sind – sonst ließe sich über einzahlen(Betrag.euro(-1_000_000)) doch wieder Geld abziehen.
  • Der Konstruktor lehnt ein Konto ohne Inhaber ab. Ein Objekt, das aus dem Konstruktor kommt, ist damit von Anfang an gültig.
  • Die Prüfung steht in einer privaten Hilfsmethode pruefePositiv – einmal geschrieben, an zwei Stellen benutzt.

Wie wird „abgelehnt“? Mit

throw new IllegalArgumentException("Der Betrag muss größer als 0 sein: " + betrag);

Das löst eine Exception aus: Das Programm bricht an dieser Stelle mit der Meldung ab – wie bei einer NumberFormatException, nur dass wir sie diesmal selbst auslösen. Wie man auf Exceptions reagiert, lernen wir in einem eigenen Kapitel. Für jetzt reicht: Ungültige Werte kommen nicht durch.

Terminal-Fenster
Exception in thread "main" java.lang.IllegalArgumentException: Der Betrag muss größer als 0 sein: -1.000.000,00 €
at de.drv.bank.Konto.pruefePositiv(Konto.java:80)
…

kontonummer, inhaber und eroeffnetAm sind final: Sie bekommen im Konstruktor ihren Wert und können danach nie mehr geändert werden – nicht einmal von der eigenen Klasse. Versucht es eine Methode trotzdem, meldet Eclipse: The final field Konto.kontonummer cannot be assigned. Vergisst der Konstruktor, ein final-Feld zu setzen: The blank final field … may not have been initialized.

kontostand ist nicht final – er ändert sich ja bei jeder Buchung. Der Betrag selbst ist unveränderlich; ändern kann sich nur, auf welchen Betrag das Feld zeigt.

Für den Kunden gilt dasselbe – mit einer Ausnahme: Ein Name kann sich ändern, etwa durch Heirat. Hier ist ein Setter fachlich sinnvoll. Aber auch er prüft:

Kunde.java
package de.drv.bank;
import java.time.LocalDate;
import java.time.Period;
public class Kunde {
private String name;
private final LocalDate geburtsdatum;
public Kunde(String name, LocalDate geburtsdatum) {
pruefeName(name);
if (geburtsdatum == null || geburtsdatum.isAfter(LocalDate.now())) {
throw new IllegalArgumentException("Ungültiges Geburtsdatum: " + geburtsdatum);
}
this.name = name;
this.geburtsdatum = geburtsdatum;
}
public String getName() {
return name;
}
public LocalDate getGeburtsdatum() {
return geburtsdatum;
}
public int getAlter() {
return Period.between(geburtsdatum, LocalDate.now()).getYears();
}
public void setName(String name) {
pruefeName(name);
this.name = name;
}
private static void pruefeName(String name) {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("Der Name darf nicht leer sein.");
}
}
}

getAlter() ist ein Getter ohne eigenes Feld: Das Alter wird jedes Mal aus dem Geburtsdatum berechnet. Von außen ist das nicht zu unterscheiden – und genau das ist der Vorteil der Kapselung. Würde man das Alter in einem Feld speichern, wäre es nach dem nächsten Geburtstag falsch.

ohne Kapselung mit Kapselung
Jeder Code kann jeden Wert setzen Werte ändern sich nur über Methoden mit Regeln
Ein Fehler kann überall entstehen Die Regeln stehen an einer Stelle
Wer die Felder umbenennt, muss allen Code ändern, der sie benutzt Die Felder sind ein internes Detail – nur die Methoden zählen

Den letzten Punkt kennst du schon vom Betrag: Ob er intern mit long oder mit BigDecimal rechnet, merkt niemand, der ihn benutzt.

Meldung in Eclipse Ursache
The field Konto.kontostand is not visible Zugriff auf ein private-Feld von außen – Getter verwenden
The method setKontostand(Betrag) is undefined for the type Konto Es gibt absichtlich keinen Setter
The final field … cannot be assigned Ein final-Feld soll nach dem Konstruktor geändert werden
The blank final field … may not have been initialized Ein Konstruktor setzt ein final-Feld nicht
IllegalArgumentException beim Programmlauf Eine Regel wurde verletzt – die Meldung sagt, welche
  1. Kapsele Konto und Kunde wie oben gezeigt. Lass die Klasse Hintertuer aus dem letzten Kapitel noch einmal laufen. Was meldet Eclipse?

    Lösung

    Beide Zeilen der Hintertür werden rot: The field Konto.kontostand is not visible und The field Konto.kontonummer is not visible. Das Programm lässt sich gar nicht erst übersetzen – der Fehler wird gefunden, bevor er passieren kann. Lösche die Klasse danach.

  2. Passe Bankdemo an, sodass es nur noch Konstruktoren, Methoden und Getter benutzt – keine Felder mehr. Gib den Kontostand über getKontostand() aus. Versuche zum Schluss, einen negativen Betrag einzuzahlen.

    Lösung

    Die letzte Zeile versucht, −1.000.000 € einzuzahlen – und bricht mit der IllegalArgumentException ab.

    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));
    Konto konto = new Konto(anna, Betrag.euro(250));
    konto.abheben(Betrag.euro(19, 99));
    System.out.println(konto.beschreibung());
    System.out.println("Kontostand: " + konto.getKontostand());
    konto.einzahlen(Betrag.euro(-1_000_000));
    }
    }
  3. Schreibe eine Testklasse KontoTest für das Konto. Prüfe mindestens: neues Konto ist leer, Einzahlen, Abheben mit und ohne Deckung, Überweisen mit und ohne Deckung, verschiedene Kontonummern.

    Lösung

    Beim Test der Kontonummern wird nur geprüft, dass sie verschieden sind – nicht, welche Nummer genau herauskommt. Welche Nummer ein Konto bekommt, hängt davon ab, wie viele Konten vorher erzeugt wurden, auch in anderen Tests. Tests, die von der Reihenfolge abhängen, sind eine häufige Fehlerquelle.

    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.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));
    @Test
    @DisplayName("Ein neues Konto ist leer")
    void neuesKontoIstLeer() {
    assertEquals(Betrag.NULL, new Konto(anna).getKontostand());
    }
    @Test
    @DisplayName("Startguthaben wird gebucht")
    void startguthaben() {
    assertEquals(Betrag.euro(100), new Konto(anna, Betrag.euro(100)).getKontostand());
    }
    @Test
    @DisplayName("Einzahlen erhöht den Kontostand")
    void einzahlen() {
    Konto konto = new Konto(anna);
    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 = new Konto(anna, 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 = new Konto(anna, 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 = new Konto(anna, Betrag.euro(100));
    Konto nach = new Konto(anna);
    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 = new Konto(anna, Betrag.euro(10));
    Konto nach = new Konto(anna);
    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(new Konto(anna).getKontonummer(), new Konto(anna).getKontonummer());
    }
    }
  4. Lass Eclipse für ein Testobjekt Getter und Setter erzeugen: Lege eine kleine Klasse mit drei private-Feldern an und wähle Source → Generate Getters and Setters…. Welche davon würdest du behalten?

Lösung
Konto.java
package de.drv.bank;
import java.time.LocalDate;
public 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;
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;
}
public Konto(Kunde inhaber, Betrag startguthaben) {
this(inhaber);
einzahlen(startguthaben);
}
public int getKontonummer() {
return kontonummer;
}
public Kunde getInhaber() {
return inhaber;
}
public LocalDate getEroeffnetAm() {
return eroeffnetAm;
}
public Betrag getKontostand() {
return kontostand;
}
public void einzahlen(Betrag betrag) {
pruefePositiv(betrag);
kontostand = kontostand.plus(betrag);
}
public boolean abheben(Betrag betrag) {
pruefePositiv(betrag);
if (betrag.istGroesserAls(kontostand)) {
return false;
}
kontostand = kontostand.minus(betrag);
return true;
}
public boolean ueberweisen(Konto ziel, Betrag betrag) {
if (!abheben(betrag)) {
return false;
}
ziel.einzahlen(betrag);
return true;
}
public String getKontokennung() {
return BANKLEITZAHL + "/" + kontonummer;
}
public String beschreibung() {
return "Konto " + getKontokennung() + " (" + inhaber.getName() + "): " + kontostand;
}
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
Kunde.java
package de.drv.bank;
import java.time.LocalDate;
import java.time.Period;
public class Kunde {
private String name;
private final LocalDate geburtsdatum;
public Kunde(String name, LocalDate geburtsdatum) {
pruefeName(name);
if (geburtsdatum == null || geburtsdatum.isAfter(LocalDate.now())) {
throw new IllegalArgumentException("Ungültiges Geburtsdatum: " + geburtsdatum);
}
this.name = name;
this.geburtsdatum = geburtsdatum;
}
public String getName() {
return name;
}
public LocalDate getGeburtsdatum() {
return geburtsdatum;
}
public int getAlter() {
return Period.between(geburtsdatum, LocalDate.now()).getYears();
}
public void setName(String name) {
pruefeName(name);
this.name = name;
}
private static void pruefeName(String name) {
if (name == null || name.isBlank()) {
throw new IllegalArgumentException("Der Name darf nicht leer sein.");
}
}
}