Objektreferenzen in Java: Werte, Aliasse und Gleichheit

Eine Java-Variable enthält einen Wert. Entscheidend ist, ob dieser Wert ein gewöhnliches Datum oder eine Referenz ist, die zu einem Objekt führt. Eine Zuweisung kopiert in beiden Fällen diesen Wert.

Primitive Daten und Objektreferenzen

Java hat acht primitive Datentypen: byte, short, int, long, float, double, char und boolean. Eine Variable eines primitiven Typs enthält ihr Datum direkt. Eine Referenzvariable enthält eine Referenz auf ein Objekt oder den besonderen Wert null. Klassen wie String, Scanner und ArrayList, deine eigenen Klassen und Arrays sind Referenztypen.

Bei new Counter() erzeugt Java ein Objekt, führt seinen Konstruktor aus und liefert eine Referenz. Die Zuweisung speichert diese Referenz in c. Zeichne die Variable als Kästchen mit einem Pfeil zu einem separaten Objekt. Jede Auswertung von new erzeugt ein eigenes Objekt, auch wenn die Argumente übereinstimmen.

Kopiere den Wert und verfolge das Ergebnis

Bei primitiven Werten lässt eine Änderung der kopierten Variablen die erste Variable unverändert:

int a = 5;
int b = a;
b = b + 1;

Die letzte Zeile liest 5 aus b, addiert 1 und speichert 6 in b. Der Wert in a bleibt 5.

Verwende für ein Referenzbeispiel diese kleine Klasse:

class Counter {
    private int value;

    Counter() { this.value = 0; }
    Counter(int value) { this.value = value; }
    void increase() { value++; }
    int value() { return value; }
}

Verfolge nun diese Anweisungen:

Counter first = new Counter();
Counter second = first;
second.increase();
System.out.println(first.value()); // 1

Nur die erste Zeile erzeugt einen Zähler. Die zweite Zeile kopiert die Referenz. Der Methodenaufruf ändert daher den einen Zähler, den beide Variablen erreichen. Für einen unabhängigen Zähler mit gleichen Daten schreibe new Counter(first.value()). Das Kopieren einer Variablen ruft keinen Konstruktor auf.

Wrapper und unveränderliche Strings

Jeder primitive Datentyp hat eine Wrapperklasse, etwa Integer, Double, Boolean oder Character. Wrappervariablen enthalten Referenzen oder null. Java kann automatisch zwischen einem primitiven Wert und seinem Wrapper umwandeln. Diese Umwandlungen heißen Autoboxing und Unboxing. Listen enthalten Referenzen, daher lautet der Typ einer Liste ganzer Zahlen ArrayList<Integer>.

Auch String ist ein Referenztyp, aber seine Objekte sind unveränderlich: Ihre Zeichen können nach der Erzeugung nicht geändert werden.

String s = "java";
String t = s;
t = t.toUpperCase();

Hier verweist s weiterhin auf „java“ und t auf „JAVA“. Die letzte Zeile weist das Ergebnis t zu. Sie ändert nicht den gemeinsam genutzten ursprünglichen String. String-Methoden können das ursprüngliche Objekt wiederverwenden, wenn keine Änderung nötig ist.

Die Ausgabe eines Objekts verwendet dessen Methode toString(). Ohne Überschreibung hat das geerbte Ergebnis eine Form wie Counter@7e9e5f8a: Klassenname, @ und ein hexadezimaler Hashcode. Definiere toString(), wenn die Ausgabe die Daten des Objekts zeigen soll.

Zwei Variablen, die auf dasselbe Objekt verweisen, sind Aliasse. Ein Alias bietet einen weiteren Weg zu vorhandenen Daten. Halte beim Nachvollziehen eines Programms die Variablen und die Objekte, die sie erreichen, auseinander.

Eine Zustandsänderung ändert Daten, eine Neuzuweisung eine Variable

Eine Zustandsänderung ändert den Zustand eines Objekts, etwa sein gespeichertes Gewicht. Eine Neuzuweisung legt einen anderen Wert in einer Variablen ab. Bei einer Referenzvariablen ändert sich dadurch ihr Pfeil.

Verwende eine Box, deren Gewicht in Kilogramm angegeben wird:

class Box {
    private double weight;
    Box(double weight) { this.weight = weight; }
    double getWeight() { return weight; }
    void setWeight(double weight) { this.weight = weight; }
}

Verfolge diese Abfolge:

Box a = new Box(2);
Box b = a;
b.setWeight(5);
b = new Box(7);

1. Zeichne die Variable a so, dass sie auf Objekt A mit dem Gewicht 2 zeigt.
2. Zeichne b so, dass es auf dasselbe Objekt A zeigt. Es gibt weiterhin eine Box.
3. Ändere das Gewicht in Objekt A auf 5. Beide Wege führen nun zum Gewicht 5.
4. Erzeuge Objekt B mit dem Gewicht 7 und richte nur b darauf aus.

Am Ende ist a.getWeight() gleich 5 und b.getWeight() gleich 7. Die vierte Anweisung setzt weder Objekt A zurück noch richtet sie a auf Objekt B aus.

Erreichbarkeit bestimmt die Lebensdauer eines Objekts

Ein Objekt ist erreichbar, solange das laufende Programm einer nutzbaren Referenzkette zu ihm folgen kann. Diese Kette kann über eine Variable, ein Objektfeld oder ein Listenelement führen. Das Verschwinden einer lokalen Variablen allein macht ein Objekt daher nicht unerreichbar, wenn eine Liste es noch enthält.

Setze den Ablauf mit a = null; fort. Objekt A mit einem Gewicht von 5 kg hat in diesem Beispiel nun keinen erreichbaren Pfad mehr. Es kann von der automatischen Speicherbereinigung entfernt werden. Java gibt den Speicher unerreichbarer Objekte automatisch frei, aber die Speicherbereinigung entscheidet, wann. Die Zuweisung verspricht keine sofortige Bereinigung. Objekt B bleibt über b erreichbar.

Du gibst Java-Objekte nicht von Hand frei. Wenn ein Programm seine letzte nutzbare Referenz auf ein Objekt verliert, verliert es auch die Möglichkeit, dessen Daten zu untersuchen oder zu ändern.

Finde die verborgenen Aliasse

Aliasse entstehen, wenn ein Objekt zu einer Liste hinzugefügt, an eine Methode übergeben, aus einer Methode zurückgegeben oder im Feld eines anderen Objekts gespeichert wird. Jede dieser Operationen kann eine Referenz weitergeben. Bevor du ein von anderswo erhaltenes Objekt änderst, bestimme, welcher andere Code es noch erreichen kann.

Ein häufiger Fehler beginnt mit dem Gedanken: „Ich habe die Variable kopiert, also habe ich meine eigene Box.“ Verwende ein neues Objekt, wenn Änderungen unabhängig sein sollen. Um den Fehler zu finden, zähle Objekterzeugungen und Zuweisungen getrennt, beschrifte jedes Objekt einmal und gehe alle Anweisungen der Reihe nach durch. Zeichne kein Objekt neu, nur weil eine zweite Variable darauf zeigt.

Der Wert null bedeutet, dass eine Referenz zu keinem Objekt führt. Das ist für ein fehlendes Ergebnis nützlich, aber ein Programm muss das Fehlen behandeln, bevor es versucht, ein Objekt zu verwenden.

Fehlend ist nicht leer

String text = ""; verweist auf einen echten String der Länge 0. String text = null; verweist auf keinen String, sodass es kein Objekt gibt, auf dem length() aufgerufen werden kann.

Eine Variable eines primitiven Typs kann kein null enthalten: int x = null; lässt sich nicht kompilieren. Ein Wrapper kann diesen Wert enthalten: Integer x = null; lässt sich kompilieren. Die Umwandlung dieses Wrappers in einen primitiven Wert mit int y = x; löst eine NullPointerException aus, weil Unboxing ein Wrapperobjekt benötigt.

Felder erhalten beim Erzeugen eines Objekts anfängliche Standardwerte. Referenzfelder beginnen mit null, numerische Felder mit 0 und boolesche Felder mit false, bis bei der Initialisierung andere Werte zugewiesen werden. Lokale Variablen haben keinen Standardwert. Das Lesen einer lokalen Variablen vor ihrer Zuweisung führt zu einem Kompilierfehler wie „variable might not have been initialized“.

Finde die fehlende Referenz

Der Aufruf einer Instanzmethode über null, der Zugriff auf ein Instanzfeld darüber oder das Lesen einer Arraylänge darüber löst zur Laufzeit eine NullPointerException aus. Zum Beispiel:

String name = null;
System.out.println(name.length());

Lies die Zeilennummer der Ausnahme und bestimme dann, welche Referenz in dieser Zeile fehlte. Hilfreiche Meldungen sind seit Java 15 standardmäßig aktiviert. Eine Meldung kann Cannot invoke "SimpleDate.getYear()" because "this.birthday" is null lauten. Lokale Namen können je nach Kompilierung als Platzhalter wie <local4> erscheinen. Verfolge den Ablauf zurück bis zu dem Konstruktor, der Zuweisung oder der Suche, die das Objekt hätte liefern sollen.

Die Ausgabe einer String-Variablen mit dem Wert null gibt „null“ aus; ihre Konkatenation erzeugt Text wie „Hi null“. Diese Operationen müssen keine Instanzmethode über diese Variable aufrufen. Sie können fehlende Daten sichtbar machen, bevor ein späterer Methodenaufruf fehlschlägt.

Prüfe vor der Verwendung

Der Operator && wertet mit Kurzschluss aus: Er wertet die rechte Seite nur aus, wenn die linke wahr ist.

if (name != null && name.length() > 0) {
    System.out.println(name);
}

Ist name gleich null, ist die erste Prüfung falsch und length() wird übersprungen. Werden die beiden Prüfungen umgekehrt, entfällt dieser Schutz: Der Methodenaufruf würde zuerst ausgeführt.

Der feste String ist ein bekanntes Objekt, sodass sein equals den Wert null entgegennehmen und false zurückgeben kann. command.equals("quit") schlägt fehl, wenn command null ist. Ebenso ist x.equals(null) keine Möglichkeit, die Existenz von x zu prüfen: Der Aufruf setzt bereits ein Objekt voraus.

Mache das Fehlen zu einer klaren Entwurfsentscheidung

Initialisiere ein Listenfeld mit new ArrayList<>(), sodass sofort eine leere Collection verfügbar ist. Gibt eine Suche null für „nicht gefunden“ zurück, dokumentiere dieses Ergebnis und prüfe es an der Aufrufstelle. Fülle nicht jedes Feld mit beliebigen Objekten, nur um eine Ausnahme zu verhindern. Stelle das Objekt bereit, das das Programm benötigt, oder gib dem Fehlen eine klare Bedeutung, die der aufrufende Code behandelt.

Java übergibt jedes Argument per Wertübergabe. Ein Parameter ist eine neue Variable, die eine Kopie des Argumentwerts erhält. Bei einem Objektargument ist der kopierte Wert eine Referenz.

Den Parameter oder das Objekt ändern?

Ein Parameter eines primitiven Typs hat seine eigenen Daten:

static void addTen(int n) {
    n = n + 10;
}

Ist x gleich 5, lässt der Aufruf addTen(x) den Wert von x bei 5. Nur der lokale Parameter n wird zu 15.

Ein Referenzparameter kann dasselbe Objekt erreichen wie der aufrufende Code. Angenommen, Person.growOlder() erhöht das gespeicherte Alter:

static void celebrate(Person p) {
    p.growOlder();
}

static void replace(Person p) {
    p = new Person("Bo", 30);
}

Während celebrate(ana) sind der Parameter p und die Variable ana Aliasse. Das geänderte Alter bleibt danach sichtbar. Während replace(ana) lenkt die Zuweisung an p nur diesen Parameter um. Die Variable ana des aufrufenden Codes verweist weiterhin auf die ursprüngliche Person. Dieselbe Einschränkung gilt für eine Methode, die zwei Referenzparameter vertauscht: Sie vertauscht ihre eigenen Kopien, nicht die Variablen des aufrufenden Codes.

Ein Objekt einer anderen Klasse entgegennehmen

Ein Tor kann die Größe einer Person lesen und einen eigenen Zähler für Prüfungen führen. Diese Klasse erwartet eine Person ungleich null mit einer Methode getHeight(), die Zentimeter zurückgibt:

class HeightGate {
    private int minHeight;
    private int checks;

    HeightGate(int minHeight) {
        this.minHeight = minHeight;
    }

    boolean allowIn(Person p) {
        checks++;
        return p.getHeight() >= minHeight;
    }

    int checks() { return checks; }
}

Bei einem auf 120 cm eingestellten Tor ergeben Prüfungen von Personen mit 132 cm und 115 cm die Werte true und false. Das Tor meldet danach 2 Prüfungen. Es liest die Größe der Person über eine öffentliche Methode und ändert seinen eigenen Zähler.

Ein weiteres Objekt derselben Klasse entgegennehmen

Innerhalb von SimpleDate.before(SimpleDate other) ist this das Datumsobjekt, auf dem die Methode aufgerufen wird, und other das Argument. Eine Klasse kann die privaten Felder jedes Objekts derselben Klasse lesen.

Vergleiche bei den Feldern day, month und year der Reihe nach:

boolean before(SimpleDate other) {
    if (year != other.year) {
        return year < other.year;
    }
    if (month != other.month) {
        return month < other.month;
    }
    return day < other.day;
}

Beim 14. März 2001 und 2. November 2001 stimmen die Jahre überein und Monat 3 ist kleiner als Monat 11. Das erste Datum liegt also früher. Gleiche Datumsangaben ergeben false, weil keine vor der anderen liegt.

Person.olderThan(other) kann an birthday.before(other.birthday) delegieren. Der Datumsvergleich gehört zu den Datumsdaten. Methoden, die Instanzmethoden auf einem Parameter aufrufen, benötigen ein Argument ungleich null. Prüfe es entweder oder halte diese Anforderung in der Dokumentation der Methode fest.

Eine Methode, die ein Objekt zurückgibt, gibt eine Referenz zurück. Ihr Typ sagt dir, welche Art von Objekt zurückgegeben werden kann, aber nicht, ob das Objekt neu ist, gemeinsam genutzt wird oder fehlt. Der Zweck der Methode muss diese Entscheidung deutlich machen.

Ein Ergebnis erzeugen

Eine Fabrikmethode liefert ein Objekt. Sie kann eines erzeugen oder ein vorhandenes wiederverwenden. Hier erzeugt jeder Aufruf bewusst ein eigenes Ticket:

class TicketMachine {
    private int nextNumber = 1;

    Ticket issue() {
        Ticket t = new Ticket(nextNumber);
        nextNumber++;
        return t;
    }
}

Der Automat erwartet einen Ticket-Konstruktor, der die Nummer speichert. Drei Aufrufe erzeugen drei Tickets mit den Nummern 1, 2 und 3. Die Rückgabe einer lokalen Variablen ist sicher: Ihre Referenz wird an den aufrufenden Code kopiert, der das Objekt erreichbar halten kann, nachdem die lokale Variable ihren Gültigkeitsbereich verlassen hat.

Eine Kopiermethode verspricht ein unabhängiges Objekt. In der Klasse Counter:

Counter copy() {
    return new Counter(this.value);
}

Nach Counter a = new Counter(4); Counter b = a.copy(); b.increase(); ist a.value() gleich 4 und b.value() gleich 5. Würde a.copy() durch a ersetzt, würde der Zähler gemeinsam genutzt.

Eine Methode kann auch ein berechnetes Objekt erzeugen. Für einen Point mit den double-Feldern x und y:

Point midpoint(Point other) {
    return new Point((x + other.x) / 2.0,
                     (y + other.y) / 2.0);
}

Die Punkte (2|4) und (6|10) ergeben (4,0|7,0). Die Methode berechnet jede Koordinate und übergibt beide an einen neuen Punkt. Keiner der ursprünglichen Punkte ändert sich.

Ein bereits gespeichertes Objekt zurückgeben

Die Methode findByName eines Registers sollte die passende gespeicherte Person zurückgeben, wenn der aufrufende Code mit diesem Eintrag arbeiten muss. Die Erzeugung von new Person(name, 0) würde erfundene Ersatzdaten zurückgeben und spätere Änderungen vom Register entkoppeln.

Eine Suche kann null zurückgeben, wenn kein Treffer existiert:

Person p = register.findByName("Lin");
if (p != null) {
    System.out.println(p);
} else {
    System.out.println("Not found");
}

Ist p die gespeicherte Person, ändern Änderungen über p auch die Person, die über das Register erreichbar ist. Eine return-Anweisung kopiert das Objekt nicht.

Veränderlichen internen Zustand unter Kontrolle halten

Angenommen, Person.getBirthday() gibt sein Feld SimpleDate zurück und dieses Datum hat Setter. Der aufrufende Code kann dann den Geburtstag der Person ändern, ohne eine Person-Methode aufzurufen. Das ist eine Freigabe veränderlichen Zustands.

Um das Feld zu schützen, gib ein neues Datum zurück, das aus seinen Werten aufgebaut wird:

SimpleDate getBirthday() {
    return new SimpleDate(birthday.getDay(),
                          birthday.getMonth(),
                          birthday.getYear());
}

Diese Version setzt voraus, dass ein Geburtstagsobjekt initialisiert wurde. Andere Entwürfe verwenden ein unveränderliches Datum oder bieten gezielte Abfragen ohne Datums-Getter an. Entscheide für jede Methode über das Verhalten: find gibt normalerweise einen gespeicherten Eintrag zur gemeinsamen Nutzung zurück, während copy Unabhängigkeit schafft. Der kurze Name eines Getters allein verspricht keinen Schutz.

Komposition baut eine Klasse mithilfe von Feldern auf, deren Typen andere Klassen sind. Sie drückt eine „Hat-ein“-Beziehung aus: Eine Person hat einen Geburtstag; ein Kurs hat eine Lehrkraft. Das äußere Objekt speichert eine Referenz auf das enthaltene Objekt.

Objekte erzeugen und verbinden

Ein Konstruktor kann ein vorhandenes Datum entgegennehmen:

class Person {
    private String name;
    private SimpleDate birthday;

    Person(String name, SimpleDate birthday) {
        this.name = name;
        this.birthday = birthday;
    }

    boolean olderThan(Person other) {
        return birthday.before(other.birthday);
    }

    public String toString() {
        return name + ", born " + birthday;
    }
}

Der Aufruf new Person("Ana", new SimpleDate(14, 3, 2001)) erzeugt zuerst ein Datum und übergibt dessen Referenz an die Person. Alternativ kann ein Person-Konstruktor Tag, Monat und Jahr entgegennehmen und das Datum in seinem Rumpf erzeugen. Bei diesem Ansatz behält der aufrufende Code keine Referenz auf das neu erzeugte Datum.

Aufgaben an das enthaltene Objekt delegieren

Der Aufruf birthday.before(other.birthday) fordert das Datumsobjekt auf, Datumsangaben zu vergleichen. Person muss die Vergleiche von Jahr, Monat und Tag nicht wiederholen. Auch die Konkatenation in toString() delegiert: Java ruft toString() des Geburtstagsobjekts auf, um dessen Text zu erhalten.

Ein Datumsobjekt kann bei der Altersberechnung helfen. Beginne mit dem aktuellen Jahr minus dem Geburtsjahr. Bilde dann das Datum des diesjährigen Geburtstags und ziehe eins ab, wenn das aktuelle Datum davor liegt. Eine am 14. März 2001 geborene Person ist am 1. Januar 2026 24: Die Jahresdifferenz beträgt 25, aber der Geburtstag steht noch bevor. Am 14. März 2026 ist der Geburtstag erreicht und das Alter beträgt 25. Bleibt der Datumsvergleich in SimpleDate, müssen seine Regeln nicht in jeder Person-Methode wiederholt werden.

Entscheiden, ob das innere Objekt gemeinsam genutzt wird

Der Konstruktor oben speichert sein Argument direkt. Erhalten zwei Personen ein veränderliches SimpleDate, zeigen beide Geburtstagsfelder auf dasselbe Datum. Eine Änderung dieses Datums betrifft beide Personen.

Ein defensiver Konstruktor kann Tag, Monat und Jahr des übergebenen Datums kopieren. Ein unveränderliches Datum hat keine zustandsändernden Methoden und behält feste Werte; einfache primitive Felder können final sein. Das Kopieren bei der Eingabe ist auch dann wichtig, wenn ein Getter später eine Kopie zurückgibt, weil der ursprüngliche aufrufende Code das übergebene Objekt noch enthalten kann.

Optionale Verbindungen behandeln

Ein Course hat möglicherweise noch keine Lehrkraft. Ist das ein sinnvoller Zustand, kann teacherName() das Feld prüfen und „noch keine Lehrkraft“ zurückgeben. Andernfalls verlange eine Lehrkraft bei der Konstruktion.

In course.getTeacher().getName() benötigt jeder Instanzaufruf ein Objekt: Ein Kurs mit dem Wert null schlägt bei getTeacher() fehl, eine Lehrkraft mit dem Wert null bei getName(). Eine Methode des Kurses kann diese Prüfung auf Fehlen an einer Stelle bündeln und vermeiden, dass jeder aufrufende Code dieselbe Kette kennen muss.

Eine ArrayList<Person> ist ein Objekt, dessen Elemente Referenzen auf Personen enthalten. Die Liste verwaltet die Reihenfolge ihrer Einträge; jede Person verwaltet ihre eigenen Felder. Das sind unterschiedliche Arten von Änderungen.

Ein Objekt hinzufügen und wieder erreichen

ArrayList<Person> people = new ArrayList<>();
people.add(ana);
people.get(0).growOlder();

Dieser Code benötigt import java.util.ArrayList; und eine vorhandene Person ana ungleich null. add kopiert die Referenz. Der Aufruf von growOlder() erreicht dieselbe Person wie ana, sodass die Altersänderung über beide Wege sichtbar ist. Die Liste erzeugt hier keine zweite Person.

Du kannst ein Objekt beim Hinzufügen erzeugen: people.add(new Person("Lin", 1998));. Dabei wird ein Person-Konstruktor verwendet, der einen Namen und ein Geburtsjahr entgegennimmt. Die Liste bietet dem Programm dann über get oder eine Schleife einen Weg zu dieser neuen Person. Typargumente von Listen müssen Referenztypen sein. Verwende daher ArrayList<Integer> für ganze Zahlen.

Mit Objekten rechnen und ein Objekt auswählen

Angenommen, eine Liste enthält Pakete mit den Gewichten 2,5 kg, 4,0 kg und 1,5 kg. Eine Schleife addiert das Gewicht jedes Pakets:

double total = 0;
for (Parcel p : parcels) {
    total += p.getWeight();
}

Die laufenden Summen betragen 2,5, 6,5 und 8,0 kg. Um das schwerste Paket auszuwählen, brauchst du neben einem Vergleich auch eine Referenz:

Parcel heaviest = parcels.get(0);
for (Parcel p : parcels) {
    if (p.getWeight() > heaviest.getWeight()) {
        heaviest = p;
    }
}

Diese Auswahl setzt eine nicht leere Liste voraus. Das Ergebnis ist das Paketobjekt mit 4,0 kg, sodass der aufrufende Code auch dessen andere Methoden verwenden kann. Lege für eine leere Liste ein Ergebnis für den Fall fest, dass nichts vorhanden ist, bevor du Element 0 liest.

Jeden Eintrag durchsuchen

Eine Namenssuche in einer Klasse, die people speichert, kann so aussehen:

Person findByName(String name) {
    for (Person p : people) {
        if (p.getName().equals(name)) {
            return p;
        }
    }
    return null;
}

Diese Version erwartet Personen ungleich null mit Namen ungleich null. Der erste Treffer wird sofort zurückgegeben. Das abschließende return null gehört hinter die Schleife: Ein fehlgeschlagener Vergleich bei der ersten Person schließt spätere Treffer nicht aus.

contains, indexOf und remove(Object) suchen mithilfe von equals. Erbt Person eine identitätsbasierte Gleichheitsprüfung, stimmt eine neu erzeugte Person nicht schon deshalb mit einer vorhandenen überein, weil ihre Felder übereinstimmen.

Einen Listeneintrag entfernen, ohne das Objekt zu zerstören

Ein Objekt kann zweimal in einer Liste oder in mehreren Listen vorkommen. Das Entfernen eines Eintrags zerstört weder das Objekt noch entfernt es andere Referenzen darauf.

Entferne während einer for-each-Traversierung keine Einträge direkt aus derselben Liste. Das kann eine ConcurrentModificationException auslösen. Sammle zuerst die zu entfernenden Einträge und entferne sie dann:

ArrayList<Person> toRemove = new ArrayList<>();
for (Person p : people) {
    if (p.getName().equals("Lin")) {
        toRemove.add(p);
    }
}
people.removeAll(toRemove);

Die Traversierung endet, bevor sich die Zusammensetzung der Liste ändert. removeAll verwendet die Gleichheitsprüfung und entfernt daher Einträge, die den gesammelten Einträgen gleich sind.

Eine Klasse kann eine Liste in einem privaten Feld verwalten und Operationen anbieten, die ihrem Zweck entsprechen. Eine Playlist speichert Songs, zählt sie und berechnet die Dauer. Aufrufender Code sollte ihre Liste nicht direkt verwalten müssen.

Die Collection initialisieren und kapseln

Diese Playlist erwartet Song-Objekte ungleich null mit einer Methode seconds():

import java.util.ArrayList;

class Playlist {
    private String name;
    private ArrayList<Song> songs;

    Playlist(String name) {
        this.name = name;
        this.songs = new ArrayList<>();
    }

    void add(Song song) { songs.add(song); }
    int count() { return songs.size(); }

    int totalSeconds() {
        int total = 0;
        for (Song song : songs) {
            total += song.seconds();
        }
        return total;
    }
}

Ohne new ArrayList<>() bleibt das Referenzfeld null; der erste Aufruf von add schlägt dann fehl. Eine leere Liste ist bereits ein verwendbares Objekt der Größe 0.

Für Songs mit einer Dauer von 210 s, 185 s und 247 s gibt count() den Wert 3 zurück. Die Summe wächst von 210 auf 395 und dann auf 642 s. Die Ganzzahldivision durch 60 ergibt 10 Minuten mit einem Rest von 42 Sekunden. Eine Methode longest() kann den Song mit 247 s auswählen und zurückgeben. Dabei verwendet sie dasselbe Muster zur Auswahl einer Referenz wie beim schwersten Paket. Lege für eine leere Playlist ein Ergebnis für den Fall fest, dass kein Song vorhanden ist.

Die Listenzugehörigkeit durch Methoden schützen

Ist songs privat, verhindert das direkten Feldzugriff, aber return songs; gibt genau diese Liste nach außen frei. Aufrufender Code könnte clear() aufrufen und alle Regeln der Playlist umgehen.

Gezielte Operationen wie add, count und totalSeconds belassen die Verantwortung bei der Playlist. Ihre Methode add könnte eine maximale Größe durchsetzen oder Duplikate mit songs.contains(song) ablehnen. Für inhaltsbasierte Duplikatprüfungen muss equals der Song-Klasse festlegen, welche Felder zwei Songs gleich machen.

Erhält ein Konstruktor eine anfängliche Liste, kopiere ihre Struktur mit this.songs = new ArrayList<>(initialSongs);. Würde der Parameter direkt gespeichert, könnte der aufrufende Code einen Alias auf die interne Liste der Playlist behalten.

Eine neue Liste kann Songs weiterhin gemeinsam nutzen

Eine Abfrage kann new ArrayList<>(songs) zurückgeben. Das ist eine flache Kopie: ein neues Listenobjekt, das die vorhandenen Song-Referenzen enthält.

Eine Abfrage songsLongerThan(200) erzeugt eine neue Ergebnisliste, durchläuft die gespeicherten Songs und fügt diejenigen hinzu, deren Dauer 200 s überschreitet. Für die drei Songs oben gibt sie die Songs mit 210 s und 247 s zurück. Sollen auch die Song-Werte unabhängig sein, kopiere die veränderlichen Songs oder mache Song unveränderlich.

Identität fragt, ob zwei Referenzen zum selben Objekt führen. Inhaltliche Gleichheit fragt, ob Objekte nach den Regeln der Klasse dieselben relevanten Daten haben. Zwei separate Buchobjekte können denselben Titel und dasselbe Erscheinungsjahr beschreiben, ohne identisch zu sein.

Den richtigen Vergleich wählen

Jede Klasse erbt equals(Object) von Object. Diese Standardversion prüft die Identität. Java untersucht nicht automatisch alle Felder einer neuen Klasse.

String a = "java";
String b = new String("java");
System.out.println(a == b);      // false
System.out.println(a.equals(b)); // true

new String erzeugt ein separates Objekt, während String.equals dessen Zeichen vergleicht. Der Textvergleich beachtet die Groß- und Kleinschreibung: "Java".equals("java") ist false. equalsIgnoreCase vergleicht ohne Beachtung der Groß- und Kleinschreibung, wenn das der gewünschten Regel entspricht.

Warum Identität manchmal den Inhalt zu vergleichen scheint

Gleiche Stringliterale nutzen ein String-Objekt gemeinsam, daher ist "java" == "java" wahr. Das kann in einem kleinen Test einen Fehler verbergen. Text aus einer Eingabe oder Text, der während der Programmausführung aufgebaut wird, muss dieses Objekt nicht gemeinsam nutzen. Verwende für den Inhalt equals, unabhängig davon, woher der Text stammt.

Wrappervergleiche haben eine ähnliche Falle:

Integer a = 127, b = 127;
Integer c = 1000, d = 1000;
System.out.println(a == b);      // true
System.out.println(c.equals(d)); // true

Autoboxing verwendet Integer-Objekte für Werte von −128 bis einschließlich 127 wieder. Ob größere Werte ein Objekt gemeinsam nutzen, ist keine portable Regel für Zahlenvergleiche. In einer Standardumgebung sind die beiden Wrapper für 1000 separate Objekte, ein größerer Cache ist aber zulässig. Verwende equals der Wrapper für gleiche Wrapperwerte oder vergleiche primitive Werte. Ist eine Seite von == ein int, führt Java Unboxing für den Wrapper aus und vergleicht Zahlenwerte; das Unboxing eines Wrappers mit dem Wert null schlägt fehl.

Entscheiden, welche Felder Gleichheit definieren

Für einen Buchkatalog könnten Titel und Erscheinungsjahr die Gleichheit definieren, während die Person ignoriert wird, die das Buch gerade ausgeliehen hat. Diese ausgewählten Felder müssen die Gleichheitsmethode bestimmen. Ein anderes Programm könnte stattdessen einen eindeutigen Identifikator wählen; die geeignete Regel hängt davon ab, was seine Objekte darstellen.

Eine ArrayList verwendet equals in contains, indexOf und remove(Object). Angenommen, Book speichert nur Felder und erbt equals. Das Hinzufügen eines new Book("Dune", 1965) macht contains(new Book("Dune", 1965)) nicht wahr: Der zweite Ausdruck erzeugt ein anderes Objekt. Wird die Gleichheitsprüfung anhand von Titel und Jahr überschrieben, kann eine Suche diesen gleichen Inhalt finden.

HashSet und HashMap verwenden außerdem hashCode, um die möglichen Treffer vor der Gleichheitsprüfung einzugrenzen. Die Definition inhaltlicher Gleichheit verlangt deshalb auch eine passende Hashcode-Regel.

Eine Gleichheitsmethode muss das geerbte equals(Object) ersetzen und die Felder vergleichen, die die Bedeutung deines Objekts bestimmen. Die richtige Signatur ist ebenso wichtig wie die Vergleiche innerhalb der Methode.

Ein vollständiges Muster für die Gleichheitsprüfung

Diese Klasse verwendet Titel und Jahr, erlaubt einen Titel mit dem Wert null und hält ihre gleichheitsrelevanten Felder unveränderlich:

import java.util.Objects;

final class Book {
    private final String title;
    private final int year;

    Book(String title, int year) {
        this.title = title;
        this.year = year;
    }

    @Override
    public boolean equals(Object other) {
        if (this == other) {
            return true;
        }
        if (!(other instanceof Book)) {
            return false;
        }
        Book book = (Book) other;
        return year == book.year
            && Objects.equals(title, book.title);
    }

    @Override
    public int hashCode() {
        return Objects.hash(title, year);
    }
}

Lies equals in vier Schritten. Die Identitätsprüfung akzeptiert dasselbe Objekt sofort. Die Typprüfung lehnt alles ab, was kein Buch ist, einschließlich null. Die explizite Typumwandlung liefert eine Book-Variable, über die die Felder gelesen werden können. Der letzte Ausdruck prüft beide gleichheitsrelevanten Felder.

Der Parametertyp ist Object, nicht Book. Mit equals(Book other) überlädst du den Namen mit einer weiteren Methode und lässt das geerbte equals(Object) unverändert. Ein direkter Aufruf kann dann zu funktionieren scheinen, während ArrayList.contains weiterhin die Identität prüft. Dank @Override erkennt der Compiler diesen Signaturfehler.

Ab Java 16 lassen sich Typprüfung und explizite Typumwandlung verbinden: if (!(other instanceof Book book)) { return false; }. Nach erfolgreicher Prüfung steht book für Feldvergleiche zur Verfügung.

Vergleiche an die Feldtypen anpassen

Verwende == für ganzzahlige Felder sowie Zeichen- und boolesche Felder. Verwende equals eines Objekts für dessen Inhalt. Für ein Objektfeld, das null sein kann, gibt Objects.equals(a, b) true zurück, wenn beide Werte null sind, false, wenn nur einer null ist, und verwendet ansonsten die Gleichheitsprüfung.

Für double-Felder sorgt Double.compare(x, other.x) == 0 für eine konsistente Behandlung von Sonderwerten: Zwei NaN-Werte gelten als gleich und positive und negative null werden unterschieden. Kombiniere diese Wahl mit einer passenden Hashcode-Regel. Der direkte Gleitkommavergleich mit == behandelt NaN anders.

Den Gleichheitsvertrag prüfen

Für Referenzen ungleich null muss die Gleichheitsprüfung folgende Eigenschaften haben:

• Reflexivität: x.equals(x) ist true.
• Symmetrie: x.equals(y) und y.equals(x) stimmen überein.
• Transitivität: Wenn x gleich y und y gleich z ist, ist x gleich z.
• Konsistenz: Wiederholte Aufrufe stimmen überein, solange die verglichenen Daten unverändert bleiben.
• False für null: x.equals(null) ist false.

Zwei Bücher für „Dune“, 1965, werden als gleich verglichen. Ändert sich eines der Jahre auf 1984, sind sie ungleich. Ein Buch darf nicht gleich einem String mit seinem Titel sein: Der String würde das Buch ablehnen und damit die Symmetrie verletzen.

Manche Implementierungen verwenden other == null || getClass() != other.getClass() für die Typprüfung. Diese Prüfung lehnt unterschiedliche Laufzeitklassen ab. instanceof kann Unterklassen akzeptieren; bei der final-Klasse oben gibt es keine Unterklasse und beide Prüfungen stimmen überein.

Ein Hashcode ist eine ganze Zahl, die eine Suche eingrenzt. HashSet und HashMap verwenden ihn, um mögliche Treffer zu finden, und bestätigen eine Übereinstimmung anschließend mit equals. Er ist kein eindeutiger Objektidentifikator.

Der Vertrag gilt in eine Richtung

Gleiche Objekte müssen denselben Hashcode zurückgeben. Auch ungleiche Objekte dürfen denselben Code haben; das ist eine Kollision. Eine Kollision macht sie nicht gleich, denn die Gleichheit wird weiterhin geprüft.

Ein Hashcode muss gleich bleiben, solange sich die von equals verwendeten Informationen nicht ändern. Bei einer korrekten Implementierung schließen unterschiedliche Hashcodes Gleichheit aus, aber gleiche Hashcodes belegen sie nicht.

Wenn eine Klasse equals überschreibt, aber Object.hashCode erbt, erhalten separate gleiche Objekte häufig unterschiedliche Codes. Eine Menge kann dann beide behalten und eine Map-Abfrage mit einem neu erzeugten gleichen Schlüssel kann fehlschlagen. Der genaue Fehler ist nicht garantiert, weil unterschiedliche Objekte kollidierende geerbte Codes haben können. Korrigiere den Vertrag, statt dich auf eine bestimmte fehlgeschlagene Suche zu verlassen.

Aus den gleichheitsrelevanten Feldern berechnen

Für die Buchklasse, die Titel und Jahr vergleicht:

@Override
public int hashCode() {
    return Objects.hash(title, year);
}

Importiere java.util.Objects. Dieselben Feldwerte erzeugen nun dasselbe Ergebnis. Eine Buchmenge speichert nach dem Hinzufügen zweier gleicher Bücher einen Eintrag und eine Map kann einen Wert mit einem neu erzeugten gleichen Buchschlüssel abrufen.

Objects.hash kombiniert die Hashcodes der Felder mithilfe von 31. Für „Dune“ ist der String-Hashcode 2141736. Die Kombination dieses Titels mit dem Jahr 1965 multipliziert 31 mit der Summe aus 31 und 2141736 und addiert dann 1965: Das Ergebnis ist 66396742.

Auch die Hashcode-Berechnung für Strings verwendet 31. Für „ab“ ergeben die Zeichencodes 97 und 98 den Wert 97 mal 31 plus 98, also 3105. Längere Berechnungen können den int-Bereich überschreiten und überlaufen. Ein negativer Hashcode ist daher normal.

Den Schlüssel während der Speicherung nicht ändern

Angenommen, das Jahr eines Buchs ist veränderlich und beeinflusst seinen Hashcode. Nach dem Einfügen in eine Menge kann eine Änderung des Jahres dazu führen, dass contains(book) selbst mit derselben Referenz fehlschlägt: Die Suche verwendet nun einen anderen Code. Die Menge kann weiterhin die Größe 1 melden.

Halte gleichheitsrelevante Felder stabil, solange ein Objekt Element einer Menge oder Schlüssel einer Map ist. Müssen sie sich ändern, entferne das Objekt, solange seine alten Werte noch gelten, ändere es und füge es erneut ein. Ein Entfernungsversuch erst nach der Änderung kann auf dasselbe Suchproblem stoßen.

Auch generierte Gleichheitsprüfung braucht eine sinnvolle Datenauswahl

Java ab Version 16 unterstützt Records wie record Book(String title, int year) {}. Ein Record erzeugt die Zugriffsmethoden title() und year() sowie Gleichheitsprüfung, Hashcode-Berechnung und eine lesbare String-Darstellung aus allen seinen Komponenten. Die Komponentenfelder sind final. Dieses Beispiel ist ein sinnvoller unveränderlicher Wert, weil seine Komponenten ein String und eine ganze Zahl sind. Ein Record mit einer veränderlichen Liste würde dagegen weiterhin deren Zustand gemeinsam nutzen.

Für gewöhnliche Klassen kann eine IDE equals und hashCode gemeinsam erzeugen. Wähle die Felder aus, die die beabsichtigte Gleichheit definieren, und halte beide Methoden aufeinander abgestimmt, wenn sich diese Wahl ändert.

Die Benutzeroberfläche liest Eingaben und zeigt Ausgaben an. Die Programmlogik speichert Daten und wendet Regeln an. Bei einem getrennten Entwurf werden Werte an die Logik übergeben und Ergebnisse zurückgegeben; die Logikklassen verwenden weder Scanner noch System.out.

Die Objekte in main verbinden

public static void main(String[] args) {
    Scanner scanner = new Scanner(System.in);
    TemperatureLog log = new TemperatureLog();
    UserInterface ui = new UserInterface(scanner, log);
    ui.start();
}

Mit import java.util.Scanner; erzeugt diese Objektverdrahtung einen Eingabeleser, ein Protokoll und eine Oberfläche. Sie gehört in die Einstiegsklasse des Programms. UserInterface speichert die übergebenen Objekte in Feldern, sodass jeder Befehl mit demselben Protokoll arbeitet.

Werte zurückgeben, die jeder aufrufende Code verwenden kann

Ein Protokoll könnte add(double celsius), count(), average() und max() anbieten. Die Messwerte 18,5, 21,0 und 19,5 °C ergeben eine Summe von 59,0, eine Anzahl von 3, ein Maximum von 21,0 und einen Mittelwert von etwa 19,6667 °C. Die Benutzeroberfläche kann den zurückgegebenen Mittelwert mit Math.round(average * 10) / 10.0 runden und 19,7 °C anzeigen.

Die Rückgabe der Zahl erleichtert direkte Prüfungen. Eine Methode namens printAverage(), die nur ausgibt, koppelt eine Berechnung an die Konsolenausgabe, was die Wiederverwendung umständlicher macht.

Angenommen, für eine einfache Befehlsschleife nimmt add gültige Temperaturen an und count gibt ihre Anzahl zurück:

class UserInterface {
    private Scanner scanner;
    private TemperatureLog log;

    UserInterface(Scanner scanner, TemperatureLog log) {
        this.scanner = scanner;
        this.log = log;
    }

    void start() {
        while (true) {
            String command = scanner.nextLine();
            if ("quit".equals(command)) {
                break;
            }
            if ("count".equals(command)) {
                System.out.println(log.count());
            }
        }
    }
}

Die Schleife behandelt die Interaktion. Sie fragt das Protokoll nach einem Ergebnis und gibt es aus, ohne zu wissen, wie die Messwerte gespeichert werden. Ein Befehl für den Mittelwert sollte ein leeres Protokoll entsprechend dem dokumentierten Ergebnis der Logik behandeln oder count() prüfen, bevor er eine Methode aufruft, die Messwerte voraussetzt.

An der richtigen Stelle validieren

Die Logik kann add bei einem Messwert unter −273,15 °C false zurückgeben lassen, ohne den Wert zu speichern. Jeder aufrufende Code erhält dann dieselbe Datenregel. Die Benutzeroberfläche entscheidet, wie sie die Ablehnung meldet und erneut fragt. Auch eine hilfreiche Fehlermeldung für eine nicht numerische Eingabe gehört zur Oberfläche.

Verwende einen Scanner für System.in und übergib ihn an die lesenden Klassen. Mehrere Scanner können um gepufferte Eingaben konkurrieren und das Schließen eines Scanners schließt den zugrunde liegenden Eingabestrom. Die Lebensdauer des gemeinsam genutzten Scanners sollte der Code verwalten, der für die Programmeingabe verantwortlich ist.

Die Logik kann später über dieselben öffentlichen Methoden eine andere Oberfläche unterstützen. Die Wiederverwendung gelingt, weil Berechnungen und Gültigkeitsregeln unabhängig von einer bestimmten Befehlsschleife als Methodenergebnisse verfügbar sind.

Ein Programm mit getrennter Oberfläche und Logik kann in kleinen Schritten wachsen. Gib der Logik eine nützliche Methode, prüfe sie direkt und verbinde sie dann mit einem Befehl, der ihre Eingabe erfasst und ihr Ergebnis anzeigt.

Eine Abfrage zur Logik hinzufügen

Ein TemperatureLog, das eine initialisierte ArrayList<Double> readings speichert, kann Messwerte oberhalb eines Schwellenwerts zählen:

int countAbove(double limit) {
    int count = 0;
    for (double reading : readings) {
        if (reading > limit) {
            count++;
        }
    }
    return count;
}

Der strenge Vergleich schließt Messwerte aus, die genau dem Schwellenwert entsprechen. Für 18,5, 21,0, 19,5 und 23,0 °C gibt countAbove(20.0) den Wert 2 zurück. Platziere den Vergleich im Protokoll, damit für jeden aufrufenden Code dieselbe Regel gilt.

Der Befehl der Benutzeroberfläche liest einen Schwellenwert, ruft log.countAbove(limit) auf und gibt die Anzahl aus. Werden einzelne Befehle lang, zerlege start() in private Hilfsmethoden wie addReading() und showStatistics(). Die Hilfsmethoden organisieren die Interaktion; sie verlagern die Datenregeln nicht aus dem Protokoll heraus.

Ohne Eingabe von Befehlen prüfen

Erzeuge das Logikobjekt und rufe seine Methoden mit Werten auf, deren Ergebnisse du kennst:

TemperatureLog log = new TemperatureLog();
log.add(18.5);
log.add(21.0);
log.add(19.5);
log.add(23.0);
System.out.println(log.count() == 4);
System.out.println(log.average() == 20.5);
System.out.println(log.max() == 23.0);
System.out.println(log.countAbove(20.0) == 2);

Die Summe ist 82,0, der erwartete Mittelwert also 20,5. Gerade diese Werte haben exakte Binärdarstellungen, sodass sich die direkten Gleichheitsprüfungen für das Beispiel eignen. Prüfe außerdem ein leeres Protokoll entsprechend seinem dokumentierten Verhalten, einen Schwellenwert, der einem Messwert entspricht, und die Ablehnung ungültiger Eingaben ohne Änderung der Anzahl. Automatisierte Testwerkzeuge bauen auf derselben Idee einer bekannten Eingabe und eines erwarteten Ergebnisses auf.

Die Speicherung nur ändern, wenn sie die Abfragen weiterhin unterstützt

Eine Oberfläche, die nur average, count und max aufruft, muss nicht wissen, ob das Protokoll eine Liste enthält. Felder für laufende Summe, Anzahl und Maximum können diese drei Abfragen beantworten, ohne jeden Messwert zu behalten.

Eine Abfrage countAbove(limit) mit beliebigem Schwellenwert benötigt mehr Informationen. Die Stichproben 18, 22, 23 und 20, 20, 23 haben dieselbe Summe 63, dieselbe Anzahl 3 und dasselbe Maximum 23, aber ihre Anzahlen oberhalb von 20 betragen 2 und 1. Werden nur diese drei Aggregate gespeichert, geht der Unterschied verloren. Die öffentlichen Methoden beschreiben, was nach einer Änderung der Speicherung weiterhin funktionieren muss.

Die Entwurfsideen verbinden

Ein Rezeptbuch kann eine private Liste von Rezepten verwalten. Jedes Rezept kann Zutaten mit Mengen in Gramm und eine Kochzeit in Minuten enthalten. Die Gleichheitsprüfung kann Duplikatprüfungen unterstützen, während eine Benutzeroberfläche Rezepte über Methoden des Buchs hinzufügt, auflistet und sucht. Eine kopierte Ergebnisliste kann ihre Zusammensetzung schützen und trotzdem Rezeptobjekte gemeinsam nutzen; entscheide, ob der aufrufende Code diese Rezepte ändern darf.

Arbeite in kleinen Schritten: Implementiere eine Methode, prüfe sie und ergänze dann ihren Befehl. Wenn eine Änderung ein vorhandenes Ergebnis beeinträchtigt, kehre zu einem funktionierenden Zustand zurück und isoliere diese Änderung, bevor du eine weitere Funktion hinzufügst.