Zum Inhalt springen

toString, equals und Records

Drei Fragen sind seit Tagen offen: Warum gibt println bei manchen Objekten seltsame Kennungen wie [I@2b2fa4f7 aus? Wann sind zwei Objekte „gleich“? Und wie ist eigentlich der Betrag gebaut? In diesem Kapitel beantworten wir alle drei.

  • toString überschreiben, damit Objekte sich sinnvoll als Text zeigen
  • entscheiden, wann zwei Objekte einer Klasse gleich sind, und equals und hashCode passend schreiben
  • Records schreiben und erklären, was Java dabei automatisch erzeugt
  • entscheiden, wann ein Record und wann eine Klasse passt

Ausgangsstand für 15-bank

⤓ bank-records.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, KontoTest.java

Gib ein Konto einfach mit println aus:

System.out.println(konto);
Terminal-Fenster
de.drv.bank.Konto@55f96302

Woher kommt dieser Text? Jede Klasse in Java stammt automatisch von der Klasse Object ab und erbt deren Methoden – auch wenn wir das nirgends hingeschrieben haben. Drei davon sind besonders wichtig:

Methode macht in Object sollte meist
toString() Klassenname + @ + eine Kennung den Inhalt lesbar beschreiben
equals(Object) dasselbe wie == – ist es dasselbe Objekt? festlegen, wann zwei Objekte gleich sind
hashCode() eine Zahl, passend zu equals von Object zu unserem equals passen

Was Vererbung genau ist, sehen wir uns im nächsten Kapitel an. Für jetzt reicht: Wir können diese Methoden in unserer Klasse überschreiben, also durch eine eigene Fassung ersetzen.

Die Methode beschreibung() aus den letzten Kapiteln war im Grunde schon ein toString. Wir benennen sie um:

Konto.java (Ausschnitt)
@Override
public String toString() {
return "Konto " + getKontokennung() + " (" + inhaber.getName() + "): " + kontostand;
}
Kunde.java (Ausschnitt)
@Override
public String toString() {
return name + " (geboren am " + geburtsdatum + ")";
}
  • println(konto) und "Text " + konto rufen jetzt automatisch unsere Methode auf.
  • @Override sagt dem Compiler: „Diese Methode soll eine geerbte Methode ersetzen.“ Vertippt man sich im Namen oder in den Parametern, meldet Eclipse einen Fehler, statt still eine neue Methode anzulegen. Schreib @Override bei jedem Überschreiben dazu.

== vergleicht bei Objekten Verweise – das kennst du aus dem Kapitel Referenzen. equals dagegen soll ausdrücken, wann zwei Objekte fachlich gleich sind. Das muss jede Klasse selbst entscheiden.

Für ein Konto ist die Antwort klar: Zwei Konto-Objekte stehen für dasselbe Konto, wenn sie dieselbe Kontonummer haben. Kontostand oder Inhaber spielen dafür keine Rolle.

Konto.java (Ausschnitt)
@Override
public boolean equals(Object obj) {
if (this == obj) {
return true;
}
if (!(obj instanceof Konto anderes)) {
return false;
}
return kontonummer == anderes.kontonummer;
}

Schritt für Schritt:

  1. Der Parameter ist vom Typ Object – so ist equals in Object festgelegt, und nur so wird es überschrieben.
  2. Ist es dasselbe Objekt, ist es auf jeden Fall gleich.
  3. obj instanceof Konto anderes prüft, ob obj überhaupt ein Konto ist. Wenn ja, steht es danach als Variable anderes vom Typ Konto bereit. Ist es kein Konto – oder null –, kann es nicht gleich sein.
  4. Sonst entscheidet die Kontonummer. Weil wir in der Klasse Konto sind, dürfen wir auf das private Feld des anderen Kontos zugreifen.

Wann sind zwei Kunden gleich? Zwei verschiedene Personen können denselben Namen und denselben Geburtstag haben. Unser Kunde hat kein Merkmal, das ihn eindeutig macht – also bekommt er kein eigenes equals. Dann gilt das von Object: Gleich ist nur dasselbe Objekt. Auch das ist eine bewusste Entscheidung: Nicht jede Klasse braucht ein eigenes equals.

Wer equals überschreibt, muss auch hashCode überschreiben. Die Regel:

Sind zwei Objekte nach equals gleich, müssen sie denselben hashCode liefern.

hashCode liefert eine Zahl, mit der manche Werkzeuge Objekte blitzschnell wiederfinden – allen voran HashMap und HashSet, die wir in der zweiten Woche kennenlernen. Hält sich eine Klasse nicht an die Regel, findet eine HashMap ein gleiches Objekt nicht wieder, obwohl equals „gleich“ sagt – ein Fehler, der schwer zu finden ist.

Für das Konto ist es einfach: equals hängt nur an der Kontonummer, also auch hashCode:

Konto.java (Ausschnitt)
@Override
public int hashCode() {
return Integer.hashCode(kontonummer);
}

Hängt equals an mehreren Feldern, nimmt man Objects.hash(feld1, feld2, …) aus java.util.Objects.

Viele Klassen sind reine Werte: Sie tragen ein paar Daten, ändern sich nie und sind gleich, wenn ihre Daten gleich sind. Für sie müsste man immer dasselbe schreiben – private final-Felder, Konstruktor, Zugriffsmethoden, equals, hashCode, toString. Genau das erledigt seit Java 16 ein Record in einer Zeile.

Für einen Kontoauszug brauchen wir Buchungen: Datum, Betrag, Buchungstext.

Buchung.java
package de.drv.bank;
import java.time.LocalDate;
public record Buchung(LocalDate datum, Betrag betrag, String text) {
public Buchung {
if (datum == null || betrag == null) {
throw new IllegalArgumentException("Datum und Betrag sind Pflicht.");
}
if (text == null || text.isBlank()) {
throw new IllegalArgumentException("Eine Buchung braucht einen Text.");
}
}
public boolean istAusgabe() {
return betrag.istNegativ();
}
}

Aus der Kopfzeile record Buchung(LocalDate datum, Betrag betrag, String text) erzeugt Java automatisch:

automatisch für die Buchung
private final-Felder datum, betrag, text
Konstruktor mit allen Werten new Buchung(datum, betrag, text)
Zugriffsmethoden – ohne get datum(), betrag(), text()
equals und hashCode gleich, wenn alle Werte gleich sind
toString Buchung[datum=2026-10-07, betrag=-3,50 €, text=Kaffee]

Dazu dürfen eigene Methoden kommen – wie istAusgabe().

public Buchung { … } – ohne Parameterliste – ist ein kompakter Konstruktor. Er läuft vor dem automatisch erzeugten Konstruktor und ist der Ort für Prüfungen. Die Werte stehen unter den Namen der Komponenten bereit; die Zuweisung an die Felder erledigt Java danach selbst. Schreibt man sie trotzdem hin, meldet Eclipse: Illegal explicit assignment of a final field … in compact constructor.

Buchung kaffee = new Buchung(LocalDate.of(2026, 10, 7), Betrag.euro(-3, 50), "Kaffee");
Buchung nochmal = new Buchung(LocalDate.of(2026, 10, 7), Betrag.euro(-3, 50), "Kaffee");
System.out.println(kaffee);
System.out.println("gleich: " + kaffee.equals(nochmal));
System.out.println("Betrag: " + kaffee.betrag() + ", Ausgabe: " + kaffee.istAusgabe());
Terminal-Fenster
Buchung[datum=2026-10-07, betrag=-3,50 €, text=Kaffee]
gleich: true
Betrag: -3,50 €, Ausgabe: true

Jetzt lässt sich die vorgegebene Klasse lesen:

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) {
/** 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);
}
/** {@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;
}
/** 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);
}
}
  • record Betrag(long cent) – ein Wert mit genau einer Komponente: die Cent. Damit gibt es cent(), equals und hashCode automatisch. Deshalb funktionierte assertEquals(Betrag.euro(5), new Betrag(500)) von Anfang an.
  • NULL ist eine statische Konstante – Records dürfen statische Felder haben.
  • euro(…) sind statische Fabrikmethoden: Sie erzeugen Beträge mit einem sprechenderen Namen als der Konstruktor. Die zweite prüft ihre Eingabe.
  • plus, minus liefern neue Beträge – die Komponente ist final, ein Record ändert sich nie.
  • toString ist überschrieben, weil Betrag[cent=123456] niemandem hilft.

Und warum ein Record? Ein Betrag ist ein reiner Wert: 5 € sind 5 €, egal welches Objekt sie trägt.

  • Records sind unveränderlich: Alle Komponenten sind final. Eine Zuweisung wie cent = 5; meldet The final field Betrag.cent cannot be assigned.
  • Records können keine weiteren Instanzfelder haben (Instance fields may not be declared in a record class) – alles, was sie speichern, steht in der Kopfzeile.
  • Records können nicht von anderen Klassen erben.
Record Klasse
ein Wert: Betrag, Buchung, ein Datum ein Ding mit Identität: Konto, Kunde
ändert sich nie hat einen Zustand, der sich ändert – der Kontostand
gleich, wenn alle Daten gleich sind gleich nur über ein Merkmal – oder gar nicht
Zugriff: betrag() Zugriff: getKontostand()

Ein Konto als Record wäre falsch: Nach jeder Einzahlung bräuchte man ein neues Konto-Objekt, und zwei Konten mit zufällig gleichem Stand wären „gleich“.

Meldung bzw. Symptom Ursache
Ausgabe wie de.drv.bank.Konto@55f96302 toString nicht überschrieben
The method equals(Konto) … must override or implement a supertype method Parameter muss Object sein, nicht Konto
equals sagt „gleich“, aber eine HashMap findet nichts hashCode nicht passend überschrieben
The final field … cannot be assigned Zuweisung an eine Record-Komponente
Instance fields may not be declared in a record class zusätzliches Feld in einem Record
Illegal explicit assignment of a final field … in compact constructor Zuweisung im kompakten Konstruktor – die macht Java selbst
  1. Ersetze beschreibung() in Konto durch toString() und gib Kunde ein toString(). Passe Bankdemo an.

    Lösung
    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 anderes = new Konto(anna);
    Konto dasselbe = konto;
    System.out.println(anna);
    System.out.println(konto);
    System.out.println("konto.equals(dasselbe): " + konto.equals(dasselbe));
    System.out.println("konto.equals(anderes): " + konto.equals(anderes));
    Buchung kaffee = new Buchung(LocalDate.of(2026, 10, 7), Betrag.euro(-3, 50), "Kaffee");
    Buchung nochmal = new Buchung(LocalDate.of(2026, 10, 7), Betrag.euro(-3, 50), "Kaffee");
    System.out.println(kaffee);
    System.out.println("gleich: " + kaffee.equals(nochmal));
    System.out.println("Betrag: " + kaffee.betrag() + ", Ausgabe: " + kaffee.istAusgabe());
    }
    }
  2. Gib dem Konto equals und hashCode über die Kontonummer. Ergänze KontoTest um Tests für die Gleichheit und für toString.

    Lösung

    Der Test für toString prüft mit contains, ob die wichtigen Teile vorkommen – nicht den ganzen Text. So bleibt er gültig, wenn sich die Formulierung ändert.

    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());
    }
    @Test
    @DisplayName("Ein Konto ist gleich zu sich selbst, aber nicht zu einem anderen")
    void gleichheit() {
    Konto konto = new Konto(anna);
    Konto dasselbe = konto;
    assertEquals(konto, dasselbe);
    assertNotEquals(konto, new Konto(anna));
    assertEquals(konto.hashCode(), dasselbe.hashCode());
    }
    @Test
    @DisplayName("toString enthält Kontokennung, Inhaber und Kontostand")
    void textdarstellung() {
    Konto konto = new Konto(anna, Betrag.euro(19, 99));
    String text = konto.toString();
    assertTrue(text.contains(konto.getKontokennung()));
    assertTrue(text.contains("Anna Muster"));
    assertTrue(text.contains("19,99 €"));
    }
    }
  3. Lege den Record Buchung an – mit kompaktem Konstruktor und der Methode istAusgabe(). Schreibe eine Testklasse BuchungTest.

    Lösung
    BuchungTest.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.assertTrue;
    import java.time.LocalDate;
    import org.junit.jupiter.api.DisplayName;
    import org.junit.jupiter.api.Test;
    class BuchungTest {
    private final LocalDate heute = LocalDate.of(2026, 10, 7);
    @Test
    @DisplayName("Zwei Buchungen mit gleichen Werten sind gleich")
    void gleichheit() {
    assertEquals(new Buchung(heute, Betrag.euro(5), "Miete"), new Buchung(heute, Betrag.euro(5), "Miete"));
    }
    @Test
    @DisplayName("Ausgaben haben einen negativen Betrag")
    void ausgabe() {
    assertTrue(new Buchung(heute, Betrag.euro(-5), "Kaffee").istAusgabe());
    assertFalse(new Buchung(heute, Betrag.euro(5), "Gehalt").istAusgabe());
    }
    @Test
    @DisplayName("Textdarstellung eines Records")
    void textdarstellung() {
    assertEquals("Buchung[datum=2026-10-07, betrag=-3,50 €, text=Kaffee]",
    new Buchung(heute, Betrag.euro(-3, 50), "Kaffee").toString());
    }
    }
  4. Was wird ausgegeben? Überlege erst, dann probiere es aus.

    Betrag a = Betrag.euro(5);
    Betrag b = new Betrag(500);
    System.out.println(a == b);
    System.out.println(a.equals(b));
    System.out.println(a);
    Lösung
    false
    true
    5,00 €

    Zwei verschiedene Objekte – == ist false. Als Record vergleicht equals die Komponente cent, und die ist bei beiden 500.

  5. Lege zum Vergleich eine Klasse BuchungAlsKlasse an, die dasselbe kann wie der Record – mit Feldern, Konstruktor, Zugriffsmethoden, equals, hashCode und toString. Lass dir dabei von Eclipse helfen. Wie viele Zeilen werden es?