Java-Klassen und Objekte

Eine Klasse definiert einen Typ: die Daten, die sich seine Objekte merken, und die Operationen, die sie anbieten. Ein Objekt, auch Instanz genannt, ist ein Wert dieses Typs, der während der Programmausführung erzeugt wird. Das Schreiben einer Klassendefinition erzeugt kein Objekt.

Zustand und Verhalten

Name, Tierart und Alter eines Haustiers bilden seinen Zustand. Diese aktuellen Werte stehen in Instanzvariablen, die auch Felder genannt werden. Eine Operation wie das Feiern eines Geburtstags ist Verhalten und wird als Methode geschrieben. Die Geburtstagsmethode gehört zu dem Alter, das sie ändert, sodass die Regel an einer Stelle steht.

Stell dir eine Klasse als Bauplan vor. Viele Häuser können nach einem Plan entstehen, aber jedes Haus hat seinen eigenen Inhalt. Ebenso können zwei Haustiere derselben Definition folgen und unterschiedlich alt sein. Du schreibst die Feldnamen einmal; jedes Objekt erhält eigene Werte.

Lies eine kleine Klasse

public class Pet {
    private String name;
    private String species;
    private int age;

    public Pet(String name, String species, int age) {
        this.name = name;
        this.species = species;
        this.age = age;
    }

    public void celebrateBirthday() {
        this.age++;
    }
}

Lies dies von außen nach innen. public class Pet führt den Typ ein und die äußeren geschweiften Klammern enthalten seine Definition. Die ersten drei Deklarationen beschreiben den Zustand. Der Block namens Pet ist ein Konstruktor: Er gibt einem neuen Objekt seine ersten Werte. celebrateBirthday ist eine Methode: Sie erhöht das Alter des aktuellen Objekts. Die Wörter private und public steuern den Zugriff; spätere Beispiele verwenden sie, um den Zustand zu schützen.

Die Parameter des Konstruktors sind Werte, die beim Erzeugen eines Objekts übergeben werden. In this.age = age; bezeichnet die linke Seite das Feld des Objekts und die rechte Seite den übergebenen Parameter. Der Konstruktor speichert diese Eingabe, damit sich das Objekt nach dem Ende der Konstruktion daran erinnern kann.

Eine Klasse einsetzen

Du hast bereits Bibliotheksklassen verwendet. Scanner beschreibt Objekte, die Eingaben lesen, ArrayList beschreibt Listen und ein String-Objekt bietet Operationen wie length() an. Eine selbst geschriebene Klasse folgt derselben Grundidee: Sie stellt dem Rest deines Programms einen nützlichen Typ bereit.

Ohne Pet müsste ein Programm Name, Tierart und Alter möglicherweise getrennt an viele Methoden übergeben. Es muss jede Gruppe korrekt zusammenhalten. Ein Pet-Objekt trägt die zusammengehörigen Werte als eine Einheit. Methoden auf diesem Objekt wissen, welches Alter sie verwenden sollen.

Code organisieren und benennen

Bei gewöhnlichen Quelldateien wird eine öffentliche Klasse namens Pet in Pet.java gespeichert, wobei die Groß- und Kleinschreibung übereinstimmen muss. Eine separate Klasse Main kann die main-Methode des Programms enthalten, Haustiere erzeugen und ihre Methoden aufrufen. Pet braucht keine eigene main-Methode. Klassen im selben unbenannten Paket können einander ohne Importdeklarationen verwenden; die einfachen Beispiele halten diese Klassen in einem Ordner.

Verwende für Klassen Substantive in UpperCamelCase, etwa LibraryBook. Verwende lowerCamelCase für Felder und Methoden: pageCount bezeichnet Daten; giveBack() bezeichnet eine Aktion. Diese Konventionen helfen beim Lesen, die einzelnen Teile zu erkennen, obwohl der Compiler viele andere Namen erlaubt.

Ein Objekt zu erzeugen und eine Variable zu deklarieren sind verschiedene Vorgänge. Eine Variable gibt dir einen Namen, über den du auf ein Objekt zugreifen kannst; new erzeugt das Objekt, auf das der Name verweisen wird.

Lies eine Anweisung zur Objekterzeugung

Pet luna = new Pet("Luna", "cat", 3);

Pet ist der Typ der Variable und luna ihr Name. new Pet(...) erzeugt ein neues Objekt und ruft einen passenden Konstruktor mit drei Argumenten auf. Der Konstruktor speichert Name, Tierart und Alter. Die entstehende Referenz wird luna zugewiesen.

Eine Referenz sagt Java, welches Objekt es verwenden soll. Es ist hilfreich, eine Variable als Namen mit einem Pfeil zu einem Objekt zu zeichnen. Die Variable ist keine zweite Kopie aller Felder des Objekts.

Rufe eine Methode auf einem bestimmten Objekt auf

Der Punkt in luna.celebrateBirthday() verbindet eine Referenz mit einer Methode, die auf ihrem Objekt ausgeführt wird. Eine Methode mit Rückgabewert kann einen Wert für einen anderen Ausdruck liefern:

luna.celebrateBirthday();
int years = luna.getAge();
System.out.println(years); // 4

Hier ist getAge() eine öffentliche Methode, die das Alter des Haustiers zurückgibt. Der Geburtstagsaufruf ändert den Zustand; der Getter liest ihn. Pet.celebrateBirthday() schlägt fehl, weil diese Instanzmethode ein bestimmtes Haustier braucht. Der Klassenname allein beantwortet nicht, wessen Geburtstag es ist.

Getrennte Objekte und gemeinsam genutzte Referenzen

Pet max = new Pet("Max", "dog", 5);
luna.celebrateBirthday();
System.out.println(luna.getAge()); // 5
System.out.println(max.getAge());  // 5

Luna war bereits 4 Jahre alt, also wird sie beim nächsten Geburtstag 5. Max bleibt 5. Das gleiche Alter macht sie nicht zu demselben Objekt: Die beiden new-Ausdrücke haben getrennte Haustiere erzeugt.

Betrachte nun eine Zuweisung ohne new:

Pet other = luna;
other.celebrateBirthday();
System.out.println(luna.getAge()); // 6

Die Zuweisung kopiert die Referenz auf Luna. Beide Namen verweisen auf ein Haustier, sodass eine Änderung über other auch über luna sichtbar ist. Um ein zweites Haustier zu erzeugen, rufe new erneut auf.

Achte auf die Parameter des Konstruktors

Die Argumente müssen in Anzahl, Reihenfolge und Typ zu einem deklarierten Konstruktor passen. Nimmt der einzige verfügbare Konstruktor (String, String, int) entgegen, wird new Pet() nicht kompiliert. Java errät keine fehlenden Werte. Werden die beiden Strings vertauscht, wird der Code dagegen trotzdem kompiliert: new Pet("cat", "Luna", 3) liefert die richtigen Typen, aber die falschen Bedeutungen. Lies die Parameternamen, um die Reihenfolge zu prüfen.

Diese beiden unvollständigen Versuche scheitern aus unterschiedlichen Gründen:

Pet a;                         // declaration only
// System.out.println(a.getAge()); // a has no assigned value
// Pet b = Pet("Bo", "cat", 2);    // missing new

Einer lokalen Variable muss vor ihrer Verwendung ein Wert zugewiesen werden. Ohne new sucht Java nach einer Methode namens Pet, nicht nach einem Ausdruck zur Objekterzeugung. Ist ein Objekt vorhanden, kann seine Ausgabe Text wie Pet@8bcc55f zeigen, bis du eine lesbare toString()-Methode bereitstellst; diese Ausgabe bedeutet nicht, dass die Konstruktion fehlgeschlagen ist.

Ein Objekt braucht für jeden Wert, den es sich zwischen Methodenaufrufen merken muss, ein Feld. Wähle diese Werte, bevor du Methoden schreibst: Sie bilden den dauerhaften Zustand des Objekts.

Deklariere Felder mit passenden Typen

Ein Feld steht innerhalb der geschweiften Klammern der Klasse, aber außerhalb aller Konstruktoren und Methoden. Eine Deklaration braucht einen Typ und einen Namen; ein Zugriffsmodifikator und ein Initialisierer können ebenfalls vorkommen.

private String title;
private int pageCount;
private boolean lentOut = false;

String eignet sich für Text, int für eine ganzzahlige Anzahl und boolean für eine Ja-Nein-Bedingung. Felder können auch Klassentypen wie ArrayList<String> verwenden. Diese Beispiele verwenden private; lässt du den Modifikator weg, gilt Paketzugriff und kein privater Zugriff.

Jedes Objekt erhält eine eigene Kopie jedes Instanzfeldes. Zwei Rectangle-Objekte haben jeweils ein width- und ein height-Feld, obwohl die Deklarationen nur einmal in der Klasse stehen.

Standardwerte sind nicht immer brauchbare Anfangswerte

Ein Feld erhält einen Standardwert, wenn Speicherplatz für das Objekt angelegt wird. Er muss nicht zum Zweck des Objekts passen. Ein Listenfeld mit dem Wert null ist keine leere Liste: Du musst die Liste erst erzeugen, bevor du ein Element hinzufügen kannst.

Lokale Variablen erhalten keinen solchen Standardwert. Innerhalb einer Methode wird int total; gefolgt von System.out.println(total); nicht kompiliert, weil total kein Wert zugewiesen wurde. Halte die Regel für Felder und die für lokale Variablen auseinander.

Entscheide, was bestehen bleiben muss

Ein Feld bleibt bei seinem Objekt. Ein Parameter ist während seines Aufrufs verfügbar und eine lokale Variable in ihrem Block, während dieser Aufruf ausgeführt wird. Muss ein Zähler seinen Zählerstand von einem Aufruf zum nächsten behalten, gehört der Stand in ein Feld. Eine vorübergehende Zwischensumme für eine Berechnung kann lokal sein.

Speichere die Eingaben; berechne abgeleitete Werte

public class Rectangle {
    private double width;
    private double height;

    public Rectangle(double width, double height) {
        this.width = width;
        this.height = height;
    }

    public double area() {
        return this.width * this.height;
    }
}

Die Abmessungen sind in Zentimetern angegeben, daher gibt area() eine Fläche in Quadratzentimetern zurück. Ein separates Feld für die Fläche würde einen weiteren Wert schaffen, der bei jeder Änderung einer Abmessung aktualisiert werden müsste. Die Berechnung aus den Abmessungen hält das Ergebnis konsistent.

Verwende ein final-Instanzfeld für einen Wert, der einmal zugewiesen wird, etwa private final String title;. Gib ihm einen Wert in seiner Deklaration oder in jedem Konstruktor. final verhindert eine Neuzuweisung. static hat eine andere Bedeutung: Es erzeugt ein gemeinsam genutztes Klassenfeld. Würde der Name eines Haustiers static erhalten, würden verschiedene Haustiere eine Namensvariable gemeinsam nutzen.

Ein Konstruktor initialisiert ein Objekt, wenn new es erzeugt. Sein Name muss mit dem der Klasse übereinstimmen und er hat keinen Rückgabetyp. Selbst void würde die Deklaration zu einer Methode machen.

Übertrage Eingaben in den Zustand

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

Ein Konstruktor nimmt üblicherweise Eingaben als Parameter entgegen und speichert sie in Feldern. Hier hat jeder Parameter denselben Namen wie sein Feld. Der bloße Name age bezeichnet den Parameter; this.age bezeichnet das Feld des Objekts, das gerade erzeugt wird. Die Zuweisung liest rechts den übergebenen Wert und schreibt links in das Feld.

Bei new Pet("Luna", "cat", 3) erhalten die Felder des neuen Objekts zuerst Standardwerte: null, null und 0. Der Konstruktor erhält dann die drei Argumente und ersetzt diese Standardwerte. Wenn die Konstruktion endet, liefert new die Referenz, die der Aufrufer speichert.

Zwei Fehler, die kompiliert werden

public Pet(String name, String species, int age) {
    name = name;
    this.species = species;
    this.age = age;
}

Beide Vorkommen von name beziehen sich auf den Parameter, sodass die erste Zeile diesen Parameter sich selbst zuweist. Der Name des Objekts bleibt null. Der Code ist zulässig, weshalb es wichtig ist, die Werte des neuen Objekts zu prüfen.

Eine Deklaration innerhalb des Konstruktors verursacht ein verwandtes Problem:

String nick = initialNick;

Existiert bereits ein Feld namens nick, erzeugt diese Zeile eine lokale Variable mit demselben Namen. Die lokale Variable verschwindet, wenn die Konstruktion endet. Schreibe this.nick = initialNick;, um die Eingabe im Feld zu speichern; wiederhole den Typ nicht.

Erkenne, wann es einen parameterlosen Konstruktor gibt

Deklariert eine Klasse keine Konstruktoren, stellt Java einen Standardkonstruktor ohne Parameter bereit. Bei einer einfachen Klasse behalten die Felder ihre deklarierten Anfangswerte oder Standardwerte. Sobald du irgendeinen Konstruktor deklarierst, stellt Java diesen Standardkonstruktor nicht mehr bereit.

Eine Klasse mit nur Pet(String name, String species, int age) kann daher nicht mit new Pet() erzeugt werden. Ergänze einen ausdrücklichen parameterlosen Konstruktor nur, wenn es dafür einen sinnvollen Anfangszustand gibt. Achte auch auf public void Pet(...): Das ist eine Methode und stellt den beabsichtigten Konstruktor daher überhaupt nicht bereit.

Setze auch interne Anfangswerte

Nicht jedes Feld muss aus einem Argument stammen. Ein neues Buch kann immer mit this.lentOut = false; beginnen. Eine Klasse, die eine Liste besitzt, kann sie bei importiertem ArrayList so initialisieren:

private ArrayList<String> tracks;

public Playlist() {
    this.tracks = new ArrayList<>();
}

Die leere Liste ist für add bereit. Bleibt tracks auf null, schlägt ein späteres tracks.add(...) mit einer NullPointerException fehl.

Ein Feldinitialisierer wird vor dem Konstruktorrumpf ausgeführt. Folgt auf private int score = 10; im Konstruktor this.score = 5;, ist der Wert von score im fertigen Objekt 5. Prüfe die Werte nach der Konstruktion und nicht nur die Werte neben den Felddeklarationen. Konstruktoren brauchen außerdem dieselben Validierungsregeln wie spätere Änderungen, damit der erste Zustand gültig ist.

Eine Klasse kann mehrere sinnvolle Möglichkeiten anbieten, ein Objekt zu erzeugen. Überladen von Konstruktoren bedeutet, Konstruktoren mit unterschiedlichen Parameterlisten zu deklarieren.

Unterscheide Konstruktoren anhand ihrer Parameter

Java unterscheidet Konstruktoren anhand von Anzahl, Typen und Reihenfolge ihrer Parameter. Die Parameternamen unterscheiden sie nicht. Box(String label) und Box(String name) beschreiben dieselbe Parameterliste und können daher nicht beide in einer Klasse deklariert werden.

Ein Haustier kann mit einer Altersangabe oder als Neugeborenes erzeugt werden:

public Pet(String name, String species, int age) {
    this.name = name;
    this.species = species;
    this.age = age;
}

public Pet(String name, String species) {
    this(name, species, 0);
}

new Pet("Pip", "rabbit") wählt den Konstruktor mit zwei Parametern. Dieser Konstruktor setzt 0 als fehlendes Alter ein und ruft den Konstruktor mit drei Parametern auf. Das neue Objekt hat am Ende den Zustand "Pip", "rabbit" und 0.

Verknüpfe die Initialisierung desselben Objekts

Innerhalb eines Konstruktors ruft this(...) einen anderen Konstruktor derselben Klasse auf. Der kürzere Konstruktor wählt Standardwerte; der umfassendere Konstruktor übernimmt die gemeinsame Initialisierung. Prüfungen in dieser Initialisierung gelten für beide Konstruktionswege.

Vergleiche zwei ähnlich aussehende Zeilen:

Die zweite Zeile füllt nicht die Felder des aktuellen Objekts. Wird ihr Ergebnis nie gespeichert, wird das zusätzliche Haustier verworfen. Die Felder des aktuellen Haustiers können weiterhin null enthalten.

Verfolge eine Kette, bevor du späteren Code nachvollziehst

Eine Uhr kann Mitternacht als Standard anbieten:

public Clock() {
    this(0, 0);
}

public Clock(int hours, int minutes) {
    this.hours = hours;
    this.minutes = minutes;
}

Gehe bei new Clock() in den parameterlosen Konstruktor, folge this(0, 0) und weise beide Felder im Konstruktor mit zwei Parametern zu. Danach kehrt die Ausführung zum parameterlosen Konstruktor zurück. So entsteht eine Uhr, nicht zwei. Ein Aufruf von new Clock(9, 5) beginnt direkt im umfassenderen Konstruktor.

Halte die Kette zulässig und verständlich

Ein Konstruktor kann höchstens einen this(...)-Aufruf enthalten. Die Kette muss schließlich eine Initialisierung erreichen, die nicht in die Kette zurückruft: Zwei Konstruktoren, die aneinander delegieren, verursachen beim Kompilieren einen Fehler wegen eines rekursiven Konstruktoraufrufs.

this(...) an den Anfang zu setzen, ist ein klarer Stil, der über Java-Versionen hinweg funktioniert. In Java 24 und früher muss der Aufruf ohne Vorschaufunktionen an erster Stelle stehen. Java 25 erlaubt vorherige Anweisungen für Aufgaben wie das Berechnen oder Prüfen von Argumenten. Diese Anweisungen dürfen weder Instanzfelder des aktuellen Objekts lesen noch dessen Instanzmethoden aufrufen; Zuweisungen an Felder, die in der Klasse ohne Initialisierer in der Deklaration deklariert wurden, sind erlaubt.

Biete Überladungen an, weil Aufrufer unterschiedliche sinnvolle Eingaben haben. Eine Uhr auf Mitternacht einzustellen ist sinnvoll; ein Buch ohne Titel muss es nicht sein. Ein vollständiger Konstruktor erzeugt nicht automatisch kürzere Überladungen.

Eine Instanzmethode wird für ein bestimmtes Objekt ausgeführt. Deklariere sie ohne static und verwende Felder dieses Objekts über Namen wie this.width. Entscheide, was der Aufrufer braucht: eine Zustandsänderung, ein zurückgegebenes Ergebnis oder beides.

Gib Berechnungen zurück; mache Zustandsänderungen ausdrücklich

Für ein Rechteck, dessen Abmessungen in Zentimetern gespeichert sind:

public double area() {
    return this.width * this.height;
}

public double perimeter() {
    return 2 * (this.width + this.height);
}

public void scale(double factor) {
    this.width = this.width * factor;
    this.height = this.height * factor;
}

Ein Rechteck mit den Seiten 3,0 und 4,0 hat eine Fläche von 12,0 Quadratzentimetern und einen Umfang von 14,0 Zentimetern. scale(2) ändert die Seiten auf 6,0 und 8,0. Die nächsten Aufrufe geben die Fläche 48,0 und den Umfang 28,0 zurück. Jede Methode liest die aktuellen Felder, sodass keine gespeicherte Fläche aktualisiert werden muss.

area() gibt eine Zahl zurück, die gespeichert oder in einer Berechnung verwendet werden kann. Würde die Methode die Zahl nur ausgeben und den Rückgabetyp void haben, könnte der Aufrufer nicht double twice = r.area() * 2; schreiben. Überlasse die Ausgabe dem Aufrufer, wenn eine Methode einen Wert berechnen soll.

Aktualisiere zusammengehörige Felder der Reihe nach

Die Methode advance() einer Uhr muss sowohl den Minuten- als auch den Stundenüberlauf behandeln:

public void advance() {
    this.minutes++;
    if (this.minutes == 60) {
        this.minutes = 0;
        this.hours++;
        if (this.hours == 24) {
            this.hours = 0;
        }
    }
}

Bei 23:58 Uhr erreicht der erste Aufruf 23:59 Uhr und überspringt beide Blöcke zum Zurücksetzen. Der nächste Aufruf erreicht kurz Minute 60, setzt sie auf 0 zurück, erhöht die Stunde auf 24 und setzt auch diese auf 0 zurück. Der endgültige Zustand ist 00:00 Uhr. Ein weiterer Aufruf ergibt 00:01 Uhr.

Verfolge Objekte getrennt

Schreibe nach jeder Anweisung eine Zeile und für jedes Feld jedes Objekts eine Spalte. Ändere nur das Objekt, auf dem die Methode aufgerufen wird. Bei Haustieren im Alter von 2 und 7 Jahren ergeben zwei Geburtstage beim ersten Haustier und setAge(1) beim zweiten die Alterswerte 4 und 1. Führe den Rumpf einer Methode nicht für jede Instanz aus, nur weil sie derselben Klasse angehören.

Eine lokale Deklaration kann das Feld verdecken, das du aktualisieren wolltest. public void reset() { int count = 0; } erzeugt nur eine temporäre Variable. this.count = 0; setzt den dauerhaft gespeicherten Zählerstand zurück.

Verwende Methoden wieder und vervollständige Rückgabepfade

Innerhalb einer Instanzmethode rufen area() und this.area() die Flächenmethode desselben Objekts auf. Eine Methode zur Beschreibung kann diese Berechnung wiederverwenden, statt ihren Ausdruck zu kopieren. Eine Methode kann auch den Zustand ändern und einen Erfolg zurückgeben, wie lend(), wenn sie ein Buch als ausgeliehen markiert und true meldet.

Eine Methode mit einem anderen Rückgabetyp als void darf nicht einfach das Ende erreichen, ohne einen kompatiblen Wert zurückzugeben. Wenn get() nur innerhalb von if (count > 0) zurückkehrt, was geschieht dann, wenn der Zählerstand 0 ist? Ergänze den nötigen Rückgabepfad oder wirf für einen Wert, den die Methode ablehnt, eine Ausnahme. Ein Pfad, der eine Ausnahme wirft, kehrt nicht zum Aufrufer zurück und braucht keinen Rückgabewert.

Frag dich, zu wem ein Wert oder eine Operation gehört, bevor du dich für oder gegen static entscheidest. Das Alter eines Haustiers gehört zu einem Haustier. Die Anzahl aller erzeugten Haustiere gehört zur Klasse als Ganzes.

Das aktuelle Objekt ist this

Innerhalb eines Konstruktors oder einer Instanzmethode verweist this auf das Objekt, das gerade konstruiert wird oder den Aufruf empfängt. In this.age++ bezeichnet es, wessen Alter sich ändert. In this.name = name unterscheidet es das Feld von einem gleichnamigen Parameter. this(...) ist die Form zur Konstruktorverkettung.

Eine statische Methode hat kein aktuelles Objekt, daher kann this dort nicht verwendet werden. Sie kann dennoch ein Objekt erzeugen oder eine Referenz erhalten und damit Instanzmethoden aufrufen.

Gemeinsam genutzte und objektbezogene Felder

public class Counter {
    private int count;
    private static int created = 0;

    public Counter() {
        this.count = 0;
        created++;
    }

    public void increment() {
        this.count++;
    }

    public int getCount() {
        return this.count;
    }

    public static int getCreated() {
        return created;
    }
}

Nach zwei Aufrufen von new Counter() gibt es zwei getrennte count-Felder, die beide anfangs 0 sind, und ein created-Feld mit dem Wert 2. Erhöhst du den ersten Zähler, ändert sich sein Zählerstand auf 1; der zweite bleibt bei 0. Counter.getCreated() gibt weiterhin 2 zurück, weil kein neues Objekt konstruiert wurde.

Arbeite von main aus über ein Objekt

public static void main(String[] args) {
    Counter c = new Counter();
    c.increment();
    System.out.println(c.getCount());
}

Die klassische main-Methode ist statisch. Ein bloßer Aufruf von increment() hätte dort kein Zielobjekt und würde nicht kompiliert. Die Variable c liefert dieses Ziel. Würdest du count statisch machen, um den Fehler zu beseitigen, würde sich der Entwurf ändern: Jeder Zähler würde dann einen Zählerstand gemeinsam nutzen.

Java 25 unterstützt auch Instanzformen von main, aber der klassische statische Methodenkopf bleibt gültig. Diese Beispiele verwenden ihn durchgehend.

Wähle Methoden und Konstanten bewusst

Eine Operation, die die Felder eines Objekts braucht, sollte eine Instanzmethode sein. Eine Operation, die nur von ihren Parametern abhängt, kann statisch sein, etwa eine Hilfsmethode, die eine Gesamtzahl von Minuten in Stunden umrechnet. Statische Aufrufe verwenden normalerweise den Klassennamen: Math.sqrt(16) oder Counter.getCreated().

Ein gemeinsamer fester Wert wird üblicherweise als Konstante deklariert:

public static final int MAX_CELSIUS = 30;

public macht sie für Aufrufer verfügbar, static gibt der Klasse ein gemeinsam genutztes Feld und final verhindert eine Neuzuweisung. UPPER_SNAKE_CASE kennzeichnet nach Konvention eine Konstante. Dies ist eine häufige Ausnahme von der Regel, Felder privat zu machen. Verwende static nicht für gewöhnliche Namen, Abmessungen oder andere Zustandswerte, die sich zwischen Objekten unterscheiden müssen.

Kapselung hält den Zustand eines Objekts mit dem Code zusammen, der ihn kontrolliert. Felder sind üblicherweise privat, während Aufrufer öffentliche Operationen verwenden. Das verbirgt Details der Speicherung und gibt der Klasse eine Stelle, an der sie ihre Regeln durchsetzen kann.

Wähle eine Zugriffsebene

Ein Paket gruppiert Klassen. Die einfachen Beispiele legen gewöhnliche Klassen ohne package-Deklaration zusammen in einem unbenannten Paket ab. Paketzugriff entsteht, wenn du den Modifikator weglässt; es gibt kein Zugriffsschlüsselwort package, das du einem Feld hinzufügen könntest.

Beginne mit dem restriktivsten sinnvollen Zugriff. Mache Felder privat, die von anderen Klassen benötigten Konstruktoren und Operationen öffentlich und interne Hilfsmethoden privat. Öffentliche Konstanten sind eine häufige Ausnahme bei Feldern.

Gib der Klasse die Kontrolle über Änderungen

Deklariert Pet ein Feld private int age;, kann eine separate Klasse Main nicht luna.age = -5; zuweisen. Der Compiler weist den Zugriff zurück. Ein Aufruf wie luna.setAge(-5) kann erlaubt sein, weil die öffentliche Methode zu Pet gehört und entscheiden kann, ob sie das Argument speichert.

Ein öffentliches Feld würde es jedem Aufrufer erlauben, diese Methode zu umgehen. Sobald alle Änderungen über den Code der Klasse erfolgen, können die Prüfungen an einer Stelle stehen. Privater Zugriff allein validiert ein Alter nicht; die Methoden müssen die Prüfungen ebenfalls durchführen.

Halte die öffentliche Schnittstelle stabil

Angenommen, eine Uhr speichert zunächst separate Felder hours und minutes. Aufrufer verwenden getHours() und getMinutes(). Später ersetzt du die Felder durch einen einzigen Wert minutesSinceMidnight:

public int getHours() {
    return this.minutesSinceMidnight / 60;
}

public int getMinutes() {
    return this.minutesSinceMidnight % 60;
}

Bei 615 gespeicherten Minuten ergibt die Division 10 und der Divisionsrest ist 15. Die Uhr meldet über dieselben Methoden 10:15 Uhr. Die Aufrufer müssen nicht umgeschrieben werden, weil sie von den öffentlichen Operationen abhingen und nicht davon, wie der Zustand gespeichert wurde. Diese Freiheit, Interna zu ändern, ist das Geheimnisprinzip.

Zugriff gehört zu Klassen, nicht zu einzelnen Objekten

Code innerhalb von Pet kann ein privates Feld eines anderen Pet-Objekts lesen. Die Zugriffsberechtigung ergibt sich daraus, dass sich der Code innerhalb der Klasse befindet. Eine andere Klasse auf oberster Ebene erhält keine Berechtigung, indem sie eine Referenz auf ein Haustier hält oder sich im selben Ordner befindet.

Für gewöhnliche Klassendeklarationen auf oberster Ebene stehen public oder kein Modifikator zur Wahl. Ein private class Pet auf oberster Ebene ist unzulässig. Eine öffentliche Klasse auf oberster Ebene gehört in die passende Quelldatei und eine gewöhnliche Quelldatei enthält höchstens eine öffentliche Klasse auf oberster Ebene.

Private Felder bilden eine Grenze im Programmentwurf. Sie verhindern, dass anderer gewöhnlicher Code direkt von internen Feldern abhängt, sind aber kein Mittel, um einen Wert vor einer Person geheim zu halten, die das Programm untersuchen kann. Verwende sie, um die Schnittstelle deiner Klasse zu steuern und ihren Zustand zu schützen.

Eine Klasse kann Aufrufern erlauben, ausgewählte Teile ihres Zustands über Methoden zu lesen oder zu ändern. Entscheide, welche Operationen die Klasse anbieten soll, bevor du für jedes Feld Zugriffsmethoden erstellst.

Gib Werte mit Gettern zurück

Ein Getter, auch Accessor genannt, gibt Informationen zurück, ohne das Objekt zu ändern. Ein gängiger Getter liest ein Feld:

public String getName() {
    return this.name;
}

public int getAge() {
    return this.age;
}

Der Rückgabetyp passt zu den bereitgestellten Informationen. Ein Getter, der etwas ausgibt und void zurückgibt, kann keinen Wert für einen Ausdruck wie pet.getAge() + 1 liefern. Der Aufrufer sollte den Wert erhalten und entscheiden, wie er ihn verwendet.

Ändere ausgewählte Werte mit Settern

Ein Setter, auch Mutator genannt, nimmt einen neuen Wert entgegen und aktualisiert den Zustand:

public void setName(String name) {
    this.name = name;
}

this.name ist das Feld. name ist der Parameter. name = name; wird kompiliert, ändert aber kein Feld. Es gibt hier keinen Rückgabewert, weil dieser Setter eine Änderung durchführen soll.

Für ein Haustier im Alter von 3 Jahren:

luna.setName("Lulu");
System.out.println(luna.getName() + " is " + luna.getAge());
// Lulu is 3

Der Aufrufer greift nie direkt auf ein Feld zu. Der Setter ändert den Namen und die Getter geben die aktuellen Werte zurück, die der Aufrufer verbinden kann.

Halte dich an Namen, die anderer Java-Code erwartet

Schreibe den ersten Buchstaben des Feldnamens nach get, set oder dem üblichen boolean-Präfix is groß. Ein Name wie getname() wird zwar möglicherweise kompiliert, folgt aber nicht der Konvention, die Werkzeuge und andere Programmierer erwarten.

Biete nur nützliche Operationen an

Der Titel eines Buches kann einen Getter und keinen Setter haben, weil Aufrufer ihn lesen, aber nicht ersetzen sollen. Ein privates final-Feld kann durchsetzen, dass ihm einmal ein Wert zugewiesen wird. Ein interner Zähler braucht möglicherweise weder Getter noch Setter, wenn nur die Klasse ihn verwendet.

Ein Setter ohne Prüfung kann denselben schädlichen Wert annehmen wie ein öffentliches Feld. Ergänze Prüfungen, wenn eine Änderung Einschränkungen unterliegt. Ziehe auch eine Aktionsmethode in Betracht: celebrateBirthday() drückt aus, dass das Alter um eins steigt, und lend() steht für einen Ausleihversuch. lend() kann den aktuellen Zustand prüfen und eine zweite Ausleihe ablehnen. Auch ein Setter kann diese Prüfung durchführen; der Name der Aktion macht dem Aufrufer die Operation aber klarer.

Ein Getter kann ein Ergebnis berechnen. getArea() kann das Produkt aus Breite und Höhe zurückgeben, ohne dass es ein Feld area gibt.

Eine Invariante ist eine Regel für den Zustand eines Objekts, die nach der Konstruktion und nach jeder öffentlichen Operation gilt. Ein Thermostat könnte Zieltemperaturen von 5 °C bis einschließlich 30 °C erlauben. Jede Möglichkeit, seinen Zielwert zu setzen, muss diesen Bereich einhalten.

Entscheide, was eine ungültige Eingabe bedeutet

Drei sinnvolle Reaktionen sind, den alten Wert zu behalten, den Wert auf eine Bereichsgrenze zu begrenzen oder eine Ausnahme zu werfen. Sie haben unterschiedliche Auswirkungen, wähle also für jede Operation eine klare Reaktion.

Für ein nicht negatives Alter eines Haustiers kann ein Setter, der ungültige Werte ignoriert, die Zuweisung nur innerhalb von if (age >= 0) vornehmen. Ist das gespeicherte Alter 4, belässt setAge(-2) es bei 4. Das Alter wird nicht zu 0.

Schreibe Bereichsprüfungen in die Klasse

public static final int MIN_CELSIUS = 5;
public static final int MAX_CELSIUS = 30;
private int target;

public void setTarget(int celsius) {
    if (celsius < MIN_CELSIUS) {
        this.target = MIN_CELSIUS;
    } else if (celsius > MAX_CELSIUS) {
        this.target = MAX_CELSIUS;
    } else {
        this.target = celsius;
    }
}

public void raise() {
    setTarget(this.target + 1);
}

Ausgehend von 20 °C speichert setTarget(35) den Wert 30. setTarget(-3) speichert 5. Nach setTarget(29) speichert ein Aufruf von raise() den Wert 30; ein weiterer Aufruf speichert weiterhin 30. Durch die Wiederverwendung des Setters kann raise() die Obergrenze nicht umgehen.

Prüfungen allein in Main können den Thermostat nicht schützen. Ein anderer Aufrufer könnte sie vergessen. Die Klasse muss die Eingabe dort prüfen, wo sie die Speicherung kontrolliert.

Validiere auch den ersten Zustand

public Thermostat(int target) {
    setTarget(target);
}

Mit diesem Konstruktor, der auf den Wertebereich begrenzt, endet new Thermostat(50) bei 30 °C. Eine direkte Zuweisung this.target = target; würde den ungültigen Anfangszustand 50 zulassen. Eine gemeinsam verwendete private Prüfmethode ist eine weitere Möglichkeit, die Validierung in Konstruktoren und späteren Methoden wiederzuverwenden.

Das Werfen einer Ausnahme ist nützlich, wenn ein ungültiges Argument einen Programmierfehler anzeigt. Ein Konstruktor kann zum Beispiel eine negative Anzahl mit throw new IllegalArgumentException("count must not be negative"); ablehnen. Das Objekt wird nicht erfolgreich konstruiert, sodass der Aufrufer kein fertiges ungültiges Objekt erhält. Eine Eingabe zu ignorieren ist einfacher, geschieht aber ohne Meldung; der Aufrufer braucht möglicherweise eine andere Möglichkeit zu bemerken, dass sich nichts geändert hat.

Halte veränderliche interne Daten im Objekt

Eine private Liste kann dennoch nach außen gelangen, wenn ein Getter die ursprüngliche Liste zurückgibt. Ein Aufrufer könnte dann Einträge hinzufügen oder entfernen, ohne die Methoden der Klasse zu verwenden, und so eine Regel zur Höchstgröße umgehen.

Für ein ArrayList<String>-Feld namens tracks liefert return new ArrayList<>(this.tracks); eine separate Liste mit denselben Strings. Eine Änderung an der zurückgegebenen Liste ändert die interne Liste nicht. Operationen wie addTrack(String title) können Listenänderungen innerhalb der Klasse halten und deren Regeln prüfen, bevor sie die Änderungen annehmen.

Ein nützliches Objekt sollte sich leicht als Text betrachten lassen. Das eingebaute toString() von Java gibt einen Klassennamen, ein @-Zeichen und einen hexadezimalen Hashcode zurück, etwa Pet@8bcc55f. Ein benanntes Paket wird Teil des Klassennamens. Der Hashcode als Text variiert und sagt üblicherweise wenig über den Zustand des Objekts aus.

Gib eine lesbare Beschreibung zurück

@Override
public String toString() {
    return this.name + " (" + this.species + ", "
        + this.age + " years)";
}

Für Luna, eine 3 Jahre alte Katze, ist der zurückgegebene String "Luna (cat, 3 years)". Die Methode liest Felder und baut einen String auf. Sie ändert das Haustier nicht und gibt nichts auf dem Bildschirm aus.

@Override weist den Compiler an zu prüfen, ob die Deklaration tatsächlich eine vorhandene Methode ersetzt. Das erkennt Fehler wie tostring mit einem kleinen s. Die Annotation formatiert das Ergebnis nicht; der Rückgabeausdruck bestimmt den Text.

Erkenne automatische Aufrufe

System.out.println(luna);
String label = "Pet: " + luna;
String details = luna.toString();

Die erste Zeile gibt die lesbare Beschreibung des Haustiers aus. Die zweite erzeugt "Pet: Luna (cat, 3 years)". Die dritte fordert dieselbe Beschreibung ausdrücklich an und speichert sie, ohne sie auszugeben. Wird eine ArrayList von Haustieren ausgegeben, verwendet ihre Darstellung innerhalb der eckigen Klammern das toString() jedes Haustiers.

Wegen der automatischen Umwandlung ist es wichtig, Text zurückzugeben. Der Aufrufer gibt das Ergebnis möglicherweise aus, speichert es oder verknüpft es. Eine Methode, die nur etwas ausgibt, kann den String nicht liefern, den all diese Aufrufer brauchen.

Achte auf den richtigen Methodenkopf

Verwende den genauen parameterlosen Methodenkopf und ergänze die Annotation. Eine Überladung mit Parametern kann eine gültige separate Methode sein, aber die Ausgabe eines Objekts liefert diese Parameter nicht.

Formatiere Werte, ohne sie zu ändern

Eine Uhr braucht zweistellige Stunden und Minuten. Innerhalb ihrer toString()-Methode:

return String.format(java.util.Locale.US,
    "%02d:%02d", this.hours, this.minutes);

Für die Stunde 9 und die Minute 5 ist der String "09:05". Jeder Formatspezifizierer %02d formatiert eine Ganzzahl mit mindestens zwei Stellen und verwendet bei Bedarf eine führende Null. String.format(java.util.Locale.US, "%.2f", 7.5) gibt "7.50" zurück. Das angegebene Gebietsschema macht die Ausgabe mit Dezimalpunkt unabhängig vom standardmäßigen Formatierungsgebietsschema des Computers.

Halte die Beschreibung kurz genug, damit du sie bei der Fehlersuche lesen kannst. Sie kann ungesetzten Zustand aufdecken: Wird ein Namensfeld mit dem Wert null mit einem String verknüpft, entsteht der Text "null", der dich zur Initialisierung zurückführt. Die Beschreibung sollte den aktuellen Zustand wiedergeben. Daher sollte die zweimalige Ausgabe des Objekts weder eine Uhr vorstellen noch einen Geburtstag feiern.

Beginne damit, was sich ein Objekt merken muss, welche Aktionen Aufrufer von ihm verlangen können und welche Zustände erlaubt sein müssen. Setze dann jeden Teil in Felder, Konstruktoren und Methoden um.

Leite den Entwurf aus einer Beschreibung ab

„Ein Bibliotheksbuch hat einen Titel, einen Autor und eine Seitenzahl. Es kann ausgeliehen und zurückgegeben werden. Solange es bereits ausgeliehen ist, kann es nicht erneut ausgeliehen werden.“

Verwende LibraryBook als Klassennamen. Speichere die drei beschreibenden Werte und einen booleschen Ausleihstatus. Titel, Autor und Seitenzahl bleiben unverändert, mache sie also final. Der Ausleihstatus ändert sich durch aussagekräftige Aktionen. Ein Setter für jedes Feld ist unnötig.

Entwickle die vollständige Klasse

public class LibraryBook {
    private final String title;
    private final String author;
    private final int pages;
    private boolean lentOut;

    public LibraryBook(String title, String author, int pages) {
        this.title = title;
        this.author = author;
        this.pages = pages;
        this.lentOut = false;
    }

    public boolean isLentOut() {
        return this.lentOut;
    }

    public boolean lend() {
        if (this.lentOut) {
            return false;
        }
        this.lentOut = true;
        return true;
    }

    public void giveBack() {
        this.lentOut = false;
    }

    @Override
    public String toString() {
        String status = this.lentOut ? "lent out" : "available";
        return this.title + " by " + this.author + ", "
            + this.pages + " pages, " + status;
    }
}

Der Konstruktor legt fest, dass das Buch verfügbar ist. lend() prüft den vorhandenen Zustand, bevor es ihn ändert; die Rückgabe von false bei einer zweiten Ausleihe erhält die Regel. giveBack() macht das Buch verfügbar. Der Getter meldet den Status und toString() beschreibt das ganze Buch, ohne es zu ändern.

Schreibe erwartete Ergebnisse vor den Aufrufen auf

In der klassischen main-Methode einer separaten Klasse Main:

LibraryBook b = new LibraryBook("Night Train", "A. Rivera", 320);
System.out.println(b);        // Night Train by A. Rivera, 320 pages, available
System.out.println(b.lend()); // true
System.out.println(b.lend()); // false
b.giveBack();
System.out.println(b.lend()); // true

Der zweite Ausleihversuch ist entscheidend: Eine Methode, die immer das Flag setzt und true zurückgibt, würde den ersten Aufruf bestehen, aber an dieser Prüfung scheitern. Teste mit isLentOut() sowohl den Zustand als auch die Rückgabewerte. Probiere außerdem ein zweites Buch aus, um zu prüfen, ob das andere Buch verfügbar bleibt, wenn eines ausgeliehen wird.

Teste dort, wo sich das Verhalten ändert

Decke jeden Konstruktor und jede öffentliche Methode ab. Probiere bei Bereichsprüfungen beide Endpunkte und Werte knapp außerhalb davon. Prüfe bei einer Uhr den Minutenüberlauf und den Übergang zu Mitternacht. Prüfe bei einem Setter, der ungültige Eingaben ablehnt oder ignoriert, ob sie die versprochene Wirkung auf den alten Zustand haben. Schreibe das erwartete Ergebnis zuerst auf, damit eine unerwartete Ausgabe nicht unbemerkt zu deiner neuen Erwartung wird.

Entwickle in kleinen Schritten: zuerst Felder und Konstruktor, dann eine lesbare Beschreibung, dann jeweils eine Operation und ihre Prüfungen. Speichere gewöhnliche öffentliche Klassen in passenden Dateien, kompiliere sie zusammen und starte die Klasse, die main enthält. Trennst du die Operationen des Modells von der Bildschirmausgabe, kann dieselbe Klasse verschiedenen Programmen dienen.