4. Klassen, Records, Schnittstellen
4.1. Objekte anhand von Beispielen
4.1.1. Überblick
Wir untersuchen nun die objektorientierte Programmierung anhand von Beispielen. Ein Objekt ist eine Entität, die Daten enthält, die ihren Zustand definieren (Felder, Attribute usw. genannt), sowie Funktionen (Methoden genannt). Ein Objekt wird auf der Grundlage einer Vorlage erzeugt, die Klasse heißt. Beispielsweise deklariert eine Klasse namens [C1] zwei Felder, [Type1 p1;] und [Type2 p2;], und zwei Methoden, [Type3 m3(...) { ... }] und [Type4 m4(...) { ... }], alle eingeschlossen in die geschweiften Klammern der Deklaration [public class C1 { ... }].
Aus der Klasse [C1] lassen sich viele Objekte wie [o1], [o2] usw. erzeugen. Alle haben die Felder [p1], [p2] usw. und die Methoden [m3], [m4] usw. Sie haben jedoch unterschiedliche Werte in ihren [pi]-Feldern und somit jeweils einen eigenen Zustand. Ist [o1] ein Objekt vom Typ [C1], bezeichnet [o1.p1] das Feld [p1] von [o1], und [o1.m3(...)] bezeichnet den Aufruf der Methode [m3] von [o1].
Betrachten wir ein erstes Objektmodell: die Klasse [Person].
4.1.2. Ein Programm aus mehreren Dateien
In den Beispielen des vorigen Kapitels passte ein Programm in eine einzige Quelldatei. Von nun an kann ein Programm aus mehreren Quelldateien bestehen: eine Klasse pro Datei sowie das Hauptprogramm. In Java muss eine öffentliche Klasse in einer Datei liegen, die ihren Namen trägt: Die öffentliche Klasse [Person] liegt in der Datei [Person.java]. Die Dateien eines Programms legen wir in einem Ordner ab – hier im Ordner [Persons] innerhalb des Ordners [04-classes]:
Ab Java 22 kann der Source-Code-Launcher – den wir bereits im vorigen Kapitel verwendet haben – ein aus mehreren Dateien bestehendes Programm ausführen: Der Befehl [java Main.java], eingegeben im Ordner [Persons], kompiliert die Datei [Main.java] im Speicher, dann bei Bedarf die übrigen Dateien des Ordners, die sie benötigt – hier [Person.java] – und führt das Programm aus. Es werden keine kompilierten Dateien auf die Festplatte geschrieben. Sie können die Dateien auch explizit mit dem Compiler [javac] kompilieren, der pro Klasse eine [.class]-Datei (Zwischencode oder „Bytecode“) schreibt, und das Programm dann mit dem Befehl [java] ausführen, wobei Sie angeben, wo die kompilierten Klassen zu finden sind (Option [-cp], der „Classpath“):
Der Launcher für mehrere Dateien genügt für die Programme dieses Kapitels, die nur Klassen aus dem JDK verwenden. Benötigt ein Programm externe Bibliotheken, verwenden wir ein Maven-Projekt, wie in Kapitel 2 eingeführt: Maven lädt die Bibliotheken herunter, kompiliert das Projekt und führt es aus. Die Dateien dieses Kapitels lassen sich unverändert in IntelliJ IDEA oder VS Code öffnen.
4.1.3. Definition der Klasse Person
Die Definition der Klasse [Person] in der Quelldatei [Person.java] lautet wie folgt:
- Zeile 1: Die Klasse ist öffentlich ([public]): Sie kann von allen anderen Klassen verwendet werden. Sie gehört zu keinem Paket – genauer gesagt gehört sie zum unbenannten Paket; Pakete werden am Ende des Kapitels behandelt;
- Zeilen 3–5: die drei Felder der Klasse. Beide Zeichenketten werden mit der leeren Zeichenkette initialisiert: Andernfalls wären sie bei der Erzeugung des Objekts [null] (ein nicht initialisiertes Objektfeld hat den Wert [null], ein numerisches Feld den Wert 0 und ein boolesches Feld den Wert [false]);
- Zeilen 8–12: eine Methode, die den Zustand des Objekts setzt;
- Zeilen 15–17: eine Methode, die den Zustand des Objekts anzeigt. [IO] ist die Konsolen-Ein-/Ausgabeklasse von Java 25, die wir im vorigen Kapitel verwendet haben.
Hier haben wir die Definition einer Klasse, also eines Datentyps. Wenn wir Variablen dieses Typs erzeugen, nennen wir sie Objekte oder Instanzen der Klasse. Eine Klasse ist somit eine Vorlage, aus der Objekte konstruiert werden. Per Konvention beginnt ein Klassenname mit einem Großbuchstaben ([Person]), während ein Feld- oder Methodenname mit einem Kleinbuchstaben beginnt ([firstName], [initialize]).
Die Member einer Klasse können Daten (Felder) oder Methoden (Funktionen) sein. Diesen Membern kann eines der folgenden Schlüsselwörter vorangestellt werden:
Schlüsselwort | Zugriff |
[private] | Auf einen privaten Member können nur die internen Methoden der Klasse zugreifen |
(keines) | Ist kein Schlüsselwort angegeben, kann jede Methode einer Klasse desselben Pakets auf den Member zugreifen. Dies ist der Standardzugriff, bekannt als „Paketzugriff“ |
[protected] | Auf einen geschützten Member können Methoden von Klassen desselben Pakets sowie Methoden abgeleiteter Klassen zugreifen (siehe das Konzept der Vererbung weiter unten) |
[public] | Auf einen öffentlichen Member kann jede Methode zugreifen, unabhängig davon, ob sie innerhalb der Klasse definiert ist |
Im Allgemeinen werden die Daten einer Klasse als privat und ihre Methoden als öffentlich deklariert. Das bedeutet, dass der Benutzer eines Objekts (der Programmierer):
- keinen direkten Zugriff auf die privaten Daten des Objekts hat;
- die öffentlichen Methoden des Objekts aufrufen kann, einschließlich derjenigen, die Zugriff auf seine privaten Daten bieten.
Die Reihenfolge, in der die Member [private], [protected] und [public] deklariert werden, ist beliebig. Beachten Sie, dass der Standardzugriff nicht privat ist: Ein ohne Schlüsselwort deklariertes Feld ist für alle Klassen des Pakets sichtbar. Sie müssen daher daran denken, [private] zu schreiben.
4.1.4. Die Methode initialize
Welche Aufgabe hat die Methode [initialize]? Da [lastName], [firstName], und [age] private Member der Klasse [Person] sind, ist eine Anweisung wie [p1.firstName = "Jean";] im Hauptprogramm ungültig. Der Compiler lehnt sie ab:
Die Compilermeldung ist auf Englisch: Das JDK hat keine französische Übersetzung seiner Meldungen. Sie nennt die Datei und die Zeilennummer des Fehlers und markiert ihn dann mit einem Zirkumflex. Wir müssen ein Objekt vom Typ [Person] über eine öffentliche Methode initialisieren. Das ist die Aufgabe der Methode [initialize]. Wir schreiben [p1.initialize("Jean", "Dupont", 30);]. Diese Syntax ist gültig, weil [initialize] öffentlich zugänglich ist.
4.1.5. Der Operator new
Es fehlt jedoch noch etwas. Die Deklaration [Person p1;] deklariert [p1] als Referenz auf ein Objekt vom Typ [Person]. Dieses Objekt existiert noch nicht, und daher ist [p1] nicht initialisiert. Wenn wir dann [p1.initialize("Jean", "Dupont", 30);] schreiben, rufen wir die Methode [initialize] des Objekts auf, auf das [p1] verweist. Dieses Objekt existiert jedoch nicht, und der Compiler meldet den Fehler: Der lokalen Variablen [p1] wurde kein Wert zugewiesen.
Schreiben wir [Person p1 = null;] gefolgt von [p1.initialize("Jean", "Dupont", 30);], geben wir mit dem Schlüsselwort [null] ausdrücklich an, dass die Variable [p1] noch auf kein Objekt verweist. Der Compiler akzeptiert das Programm, aber zur Laufzeit löst der Methodenaufruf eine [NullPointerException]-Ausnahme aus:
Seit Java 14 gibt die Ausnahmemeldung an, welche Operation fehlgeschlagen ist; [<local1>] bezeichnet die lokale Variable [p1], deren Name durch die Kompilierung im Speicher nicht erhalten blieb. Damit [p1] auf ein Objekt verweist, müssen Sie [Person p1 = new Person();] schreiben.
Damit wird ein Objekt vom Typ [Person] erzeugt, das noch nicht initialisiert ist: Seine Felder haben ihre Standardwerte – hier die leere Zeichenkette für [lastName] und [firstName], und 0 für [age]. Da [p1] nun auf ein Objekt verweist, ist die Initialisierungsanweisung für dieses Objekt, [p1.initialize("Jean", "Dupont", 30);], gültig.
4.1.6. Das Schlüsselwort this
Betrachten wir den Code der Methode [initialize]:
Die Anweisung [this.firstName = p;] bedeutet, dass dem Feld [firstName] des aktuellen Objekts ([this]) der Wert [p] zugewiesen wird. Das Schlüsselwort [this] bezeichnet das aktuelle Objekt: dasjenige, auf dem die Methode ausgeführt wird. Woher wissen wir das? Betrachten wir, wie das Objekt, auf das [p1] verweist, im aufrufenden Programm initialisiert wird: [p1.initialize("Jean", "Dupont", 30);]. Aufgerufen wird die Methode [initialize] des Objekts [p1]. Wird innerhalb dieser Methode auf das Objekt [this] Bezug genommen, ist tatsächlich das Objekt [p1] gemeint.
Wenn eine Methode eines Objekts auf ein Feld [a] dieses Objekts Bezug nimmt, ist die Schreibweise [this.a] implizit gemeint: Die Methode [initialize] hätte [firstName = p;] und [lastName = n;] schreiben können. Sie müssen [this] ausdrücklich verwenden, wenn ein Bezeichnerkonflikt besteht. Dies ist bei der Anweisung [this.age = age;] (Zeile 11) der Fall, wo [age] sowohl ein Feld des aktuellen Objekts als auch den von der Methode empfangenen Parameter [age] bezeichnet. In der Methode bezeichnet der Name [age] allein den Parameter; das Feld muss als [this.age] angesprochen werden.
4.1.7. Ein Testprogramm
Hier ein kurzes Testprogramm. Es steht in der Quelldatei [Main.java]:
- Zeile 2: Die Methode [main] ist der Einstiegspunkt des Programms. Wie im vorigen Kapitel ist sie ohne umschließende Klasse geschrieben: Die Datei [Main.java] ist eine kompakte Quelldatei (siehe den folgenden Absatz);
- Zeile 4: Erzeugung eines [Person]-Objekts, auf das [p1] verweist. Da die Klasse [Person] zum selben Paket (dem unbenannten Paket) gehört, wird sie ohne import-Anweisung erkannt;
- Zeile 5: Initialisierung des Objekts;
- Zeile 6: Anzeige seines Zustands.
Ergebnisse:
4.1.8. Kompakte Quelldateien
Für ein kurzes Beispiel ist ein Ordner mit mehreren Dateien unnötig aufwendig. Wie im vorigen Kapitel schreiben wir daher eine kompakte Quelldatei (Java 25): eine Datei, die die Methode [void main()], gegebenenfalls weitere Methoden und Felder sowie die vom Programm benötigten Klassen enthält. Wir führen sie mit dem Source-Code-Launcher aus: [java Classes01.java].
Es ist wichtig zu verstehen, wie der Compiler eine solche Datei verarbeitet. Er hüllt sie in eine implizite Klasse, die den Namen der Datei trägt ([Classes01]): Die Methoden und Felder der Datei werden zu Membern dieser Klasse, und die in der Datei deklarierten Klassen werden zu verschachtelten Klassen dieser impliziten Klasse. Die explizite Kompilierung der Datei zeigt dies:
Der vollständige Name der Klasse [Person] in der Datei [Classes01.java] lautet daher [Classes01$Person]. Das hat zwei Folgen, denen wir in den Beispielen begegnen werden:
- Eine Klasse und die in ihr enthaltenen Klassen teilen ihre privaten Member: Die Methode [main] in einer kompakten Datei hat Zugriff auf die privaten Felder der Klassen dieser Datei. Damit ein privates Feld von außerhalb seiner Klasse unzugänglich ist, müssen Sie die Klasse – wie im Ordner [Persons] – in eine eigene Datei legen;
- Eine gewöhnliche verschachtelte Klasse ist eine innere Klasse: Ihre Objekte sind an ein Objekt der umschließenden Klasse gebunden. Das fällt nicht auf, solange die Objekte von Methoden der Datei erzeugt werden, aber eine statische Methode (siehe den Abschnitt über Klassenmember) kann sie nicht erzeugen. Wir deklarieren die verschachtelte Klasse dann als [static]. Records und Schnittstellen, die später behandelt werden, sind immer statisch.
Schließlich importiert eine kompakte Datei automatisch alle öffentlichen Klassen des Moduls [java.base]: [List], [ArrayList], [BigDecimal], [Objects] ... können dort ohne die [import]-Klausel verwendet werden. Bei einer regulären Datei wie [Person.java] ist das nicht der Fall, wie wir sehen werden.
4.1.9. Eine weitere Methode initialize: Überladung
Betrachten wir weiter die Klasse [Person] und fügen ihr eine zweite Methode hinzu: [initialize]. Das Programm [Classes01.java] lautet wie folgt:
- Zeilen 2–9: das Hauptprogramm;
- Zeile 12: Die Klasse [Person] wird nach der Methode [main] deklariert. Sie ist nicht öffentlich: In einer kompakten Datei ist das unnötig;
- Zeilen 19–23: die Methode [initialize] aus dem vorigen Absatz;
- Zeilen 26–30: eine zweite Methode, [initialize].
Wir haben nun zwei Methoden mit dem Namen [initialize]: Das ist gültig, solange sie unterschiedliche Parameter (in Anzahl oder Typ) akzeptieren. Man sagt, die Methode [initialize] sei überladen. Der Compiler wählt anhand der aktuellen Parameter aus, welche Methode aufgerufen wird: [p1.initialize("Jean", "Dupont", 30)] (Zeile 4) ruft die erste auf, und [p2.initialize(p1)] (Zeile 7) ruft die zweite auf. Der Rückgabetyp allein genügt nicht, um zwei Methoden zu unterscheiden: Zwei Methoden mit demselben Namen und denselben Parametern, die sich nur im Rückgabetyp unterscheiden, würden abgelehnt.
Der Parameter der zweiten Methode ist eine Referenz ([p]) auf eine Person. Die Felder der Person ([p]) werden dann dem aktuellen Objekt ([this]) zugewiesen. Beachten Sie, dass die Methode [initialize] direkten Zugriff auf die Felder des Objekts [p] hat, obwohl sie privat sind (Zeilen 27–29). Das gilt immer: Eine Methode einer Klasse [C] hat Zugriff auf die privaten Member aller Objekte derselben Klasse [C].
Ergebnisse:
4.1.10. Konstruktoren der Klasse Person
Ein Konstruktor ist eine Methode, die den Namen der Klasse trägt und bei der Erzeugung des Objekts aufgerufen wird. Er dient im Allgemeinen dazu, das Objekt zu initialisieren. Er ist eine Methode, die Parameter akzeptieren kann, aber keinen Wert zurückgibt. Seiner Deklaration geht kein Typ voran (nicht einmal [void]).
Hat eine Klasse [C] einen Konstruktor, der n Parameter akzeptiert, kann die Deklaration und Initialisierung eines Objekts dieser Klasse in der Form [C object = new C(arg1, arg2, ... argn);] oder in zwei Schritten erfolgen: [C object;], gefolgt, später, von [object = new C(arg1, arg2, ... argn);].
Hat eine Klasse [C] einen oder mehrere Konstruktoren, muss einer dieser Konstruktoren verwendet werden, um ein Objekt dieser Klasse zu erzeugen. Hat eine Klasse [C] keinen Konstruktor, besitzt sie einen parameterlosen Standardkonstruktor, der nichts tut. Die Felder des Objekts behalten dann ihre Anfangswerte. So war es in den vorigen Programmen, in denen wir [new Person()] geschrieben hatten.
Das Programm [Classes02.java] liefert drei Konstruktoren für die Klasse [Person]:
- Zeilen 18–22: Der „Haupt“-Konstruktor initialisiert die drei Felder. Da seine Parameter dieselben Namen wie die Felder haben, werden die Felder mit [this] unterschieden;
- Zeilen 25–27: der Kopierkonstruktor. Die Anweisung [this(p.firstName, p.lastName, p.age);] ruft den Konstruktor derselben Klasse auf, der drei Parameter akzeptiert: [String], [String] und [int]. Man spricht von verketteten Konstruktoren. Dadurch wird der Initialisierungscode nur einmal geschrieben;
- Zeilen 30–32: der parameterlose Konstruktor, der ebenfalls mit dem Hauptkonstruktor verkettet ist. Da die Klasse Konstruktoren deklariert hat, besitzt sie keinen Standardkonstruktor mehr: Wenn Sie [new Person()] schreiben können wollen, müssen Sie ihn deklarieren;
- Zeilen 13–15: Die Felder werden nicht mehr bei ihrer Deklaration initialisiert; alle Konstruktoren weisen ihnen direkt oder durch Verkettung einen Wert zu.
Der Aufruf [this(...)] eines anderen Konstruktors ist nur innerhalb eines Konstruktors möglich. Bis Java 24 musste er die erste Anweisung sein; seit Java 25 dürfen ihm Anweisungen vorausgehen, die das gerade konstruierte Objekt nicht verwenden (etwa um Parameter zu prüfen oder vorzubereiten). Wir könnten die Konstruktoren auch eine Methode wie [initialize] aufrufen lassen; die Verkettung ist jedoch vorzuziehen: Der Initialisierungscode steht an einer einzigen Stelle, und ein Konstruktor sollte keine Methode aufrufen, die eine abgeleitete Klasse überschreiben könnte – wir werden sehen, warum.
Ergebnisse:
4.1.11. Objektreferenzen
Wir verwenden die Klasse [Person] aus dem vorigen Programm, lassen jedoch ihren parameterlosen Konstruktor weg und behalten die Methode [initialize(String, String, int)] vom Anfang des Kapitels bei. Das Testprogramm wird zum folgenden [Classes03.java]:
Die Methode [IO.print] (Zeilen 5, 8, …) schreibt ihren Parameter ohne Zeilenumbruch. Ergebnisse:
Wird die Variable [p1] über [Person p1 = new Person("Jean", "Dupont", 30);] (Zeile 4) deklariert, [p1] verweist sie auf das Objekt [Person("Jean", "Dupont", 30)], ist aber nicht das Objekt selbst. In C würde man von einem Zeiger sprechen, also der Adresse des erzeugten Objekts. Schreiben wir anschließend [p1 = null;], wird nicht das Objekt [Person("Jean", "Dupont", 30)] verändert, sondern die Referenz [p1] ändert ihren Wert. Das Objekt geht „verloren“, wenn keine andere Variable darauf verweist: Der Speicher, den es belegt, wird später vom Garbage Collector der virtuellen Maschine von Java freigegeben.
Wenn wir [Person p2 = p1;] (Zeile 7) schreiben, initialisieren wir die Referenz [p2]: Sie „zeigt“ auf dasselbe Objekt (sie verweist auf dasselbe Objekt) wie die Referenz [p1]. Wird also das Objekt, auf das [p1] „zeigt“ (bzw. verweist), verändert, so ist auch das Objekt verändert, auf das [p2] verweist (Zeilen 5–6 der Ergebnisse).
Wird [Person p3 = new Person(p1);] geschrieben (Zeile 10), wird ein neues [Person]-Objekt erzeugt. Auf dieses neue Objekt verweist [p3]. Verändert man das Objekt, auf das [p1] verweist, verändert man nicht dasjenige, auf das [p3] verweist (Zeile 7 der Ergebnisse).
Schließlich gibt in Zeile 20 der Operator [==], angewandt auf zwei Objektreferenzen, an, ob sie auf dasselbe Objekt verweisen: [p1] und [p2] verweisen auf dasselbe Objekt, während [p1] und [p3] auf zwei verschiedene Objekte verweisen, obwohl sie denselben Inhalt haben (Zeile 8 der Ergebnisse). Wie man den Inhalt zweier Objekte mit der Methode [equals] vergleicht, sehen wir später.
4.1.12. Übergabe von Objektreferenzen als Parameter
Im vorigen Kapitel haben wir gesehen, dass Java Methodenparameter per Wert übergibt: Die Methode erhält eine Kopie des Werts des aktuellen Parameters. Sehen wir uns an, was das bedeutet, wenn der Parameter eine Objektreferenz ist. Dazu verwenden wir die Klasse [StringBuilder] aus dem JDK. Ein [String]-Objekt kann nicht verändert werden: Eine Operation wie [s.toUpperCase()] gibt ein neues [String]-Objekt zurück. Ein [StringBuilder]-Objekt hingegen ist eine veränderliche Zeichenkette: Seine Methode [append] fügt der Zeichenkette Zeichen hinzu, ohne ein neues Objekt zu erzeugen.
Das Programm [Classes04.java] lautet wie folgt:
- Zeile 3: zwei Referenzen, [sb0] und [sb1], auf Objekte vom Typ [StringBuilder];
- Zeile 5: Sie werden an die Methode [changeStringBuilder] übergeben, deren Ergebnis – eine dritte Referenz – [sb2] zugewiesen wird;
- Zeilen 10–20: eine Methode in der kompakten Datei, die die formalen Parameter [sbf0] und [sbf1] hat. Beim Start der Methode sind [sbf0] und [sb0] zwei verschiedene Referenzen, die auf dasselbe Objekt zeigen: Die Referenz [sb0] wurde nach [sbf0] kopiert (Referenzen werden per Wert übergeben). Dasselbe gilt für [sbf1] und [sb1].
Ergebnisse:
Erläuterungen:
- [sb0] und [sbf0] sind zwei verschiedene Referenzen auf dasselbe Objekt. Dieses Objekt wurde über [sbf0] verändert (Zeile 13). Diese Änderung ist über [sb0] sichtbar (Zeile 5 der Ergebnisse);
- [sb1] und [sbf1] sind zwei verschiedene Referenzen auf dasselbe Objekt. [sbf1] wird in der Methode ein neuer Wert zugewiesen und zeigt nun auf ein neues Objekt (Zeile 15). Dies ändert nicht den Wert von [sb1], das weiterhin auf das ursprüngliche, unveränderte Objekt zeigt;
- Eine Java-Methode kann also den Wert einer Variablen des Aufrufers nicht ändern. Um ein neues Objekt an den Aufrufer zurückzugeben, liefert sie es als Ergebnis zurück (Zeilen 17 und 19). Bei mehreren Ergebnissen werden diese in einem Objekt zusammengefasst, etwa einem Record (siehe weiter unten).
Beachten Sie: Eine Methode kann das Objekt verändern, auf das ein Parameter verweist, nicht aber die Variable des Aufrufers, die die Referenz enthält. Anders als andere Sprachen wie C# unterstützt Java die Übergabe von Parametern per Referenz nicht.
4.1.13. Temporäre Objekte
In einem Ausdruck können Sie den Konstruktor eines Objekts ausdrücklich aufrufen: Das Objekt wird erzeugt, aber es gibt keine Variable, über die man später darauf zugreifen könnte (um es etwa zu verändern). Dieses temporäre Objekt wird zur Auswertung des Ausdrucks erzeugt und anschließend verworfen. Der von ihm belegte Speicherplatz wird später automatisch vom Garbage Collector freigegeben, dessen Aufgabe es ist, den Speicherplatz von Objekten freizugeben, auf die die Daten des Programms nicht mehr verweisen.
Betrachten wir das folgende Programm, [Classes05.java], in dem die Konstruktoren der Klasse [Person] eine Meldung anzeigen:
- Zeile 3: Das Objekt
[Person("Jean", *"Dupont", 30)]* wird erzeugt und dann an den Kopierkonstruktor übergeben, der ein zweites Objekt erzeugt, dessen Methode[identify]aufgerufen wird. Auf keines der beiden Objekte verweist eine Variable.
Ergebnisse:
Die Ergebnisse zeigen die aufeinanderfolgende Erzeugung der beiden temporären Objekte.
4.1.14. Zugriffsmethoden und Änderungsmethoden
Wir fügen der Klasse [Person] die erforderlichen Methoden hinzu, um den Zustand der Felder der Objekte in [Classes06.java] zu lesen oder zu ändern:
- Zeilen 23–33: die lesenden Methoden, Getter genannt;
- Zeilen 36–46: schreibende Methoden, „Setter“ genannt.
Ergebnisse:
Die Namen dieser Methoden folgen einer Konvention, die seit den Anfängen von Java besteht, nämlich „JavaBeans“: Der Getter für das Feld [age] heißt [getAge] und sein Setter [setAge]; der Getter für ein boolesches Feld namens [active] heißt stattdessen [isActive]. Viele Bibliotheken (etwa Jackson für JSON und Hibernate für Datenbanken, die wir später verwenden) stützen sich auf diese Konvention, um die Daten eines Objekts abzurufen. Anders als andere Sprachen wie C# kennt Java keine „Properties“: Der Zugriff auf den Zustand eines Objekts erfolgt immer über Methoden oder – bei unveränderlichen Objekten – über Records, die wir später behandeln. Entwicklungsumgebungen können Getter und Setter aus Feldern generieren (in IntelliJ IDEA im Menü „Code / Generate…“).
4.1.15. Setter, die empfangene Werte validieren
Der Vorteil von Änderungsmethoden gegenüber öffentlichen Feldern ist die Möglichkeit, die den Feldern zugewiesenen Werte zu kontrollieren: Eine Änderungsmethode kann die Gültigkeit des empfangenen Werts prüfen und eine Ausnahme auslösen, wenn er ungültig ist. Betrachten Sie das Programm [Classes07.java]:
Die drei Änderungsmethoden validieren den empfangenen Wert (Zeilen 60–62, 68–70, 76–78).
- Zeilen 60–62: Die Methode [isBlank] (Java 11) gibt [true] zurück, wenn die Zeichenkette leer ist oder nur aus Leerzeichen besteht. Der Test [firstName == null] wird zuerst durchgeführt: Ist [firstName] gleich [null], wertet der Operator [||] seinen zweiten Operanden nicht aus, was eine [NullPointerException] verursachen würde. Die ausgelöste Ausnahme ist vom Typ [IllegalArgumentException], der von Java bereitgestellten Ausnahme, um einen ungültigen Parameter zu melden. Dies ist eine ungeprüfte Ausnahme: Die Methode muss sie nicht mit [throws] deklarieren;
- Zeilen 34–39: Der Konstruktor initialisiert das Objekt über Zugriffsmethoden statt über Felder. So kann er die Validierungen der Zugriffsmethoden nutzen, die nur an einer Stelle geschrieben werden;
- Zeilen 58, 66, 74: Die Änderungsmethoden sind als [final] deklariert. Bei der Vererbung werden wir sehen, dass eine abgeleitete Klasse die Methoden ihrer Elternklasse überschreiben kann; das Schlüsselwort [final] verhindert dies. Ohne es könnte eine abgeleitete Klasse [setAge] neu definieren, und der Konstruktor von [Person] würde diese neue Version aufrufen, noch bevor der Konstruktor der abgeleiteten Klasse ausgeführt wurde. Der Compiler weist mit der Option [-Xlint:all] auf dieses Risiko hin (Warnung [this-escape]), und zwar bei einer öffentlichen Klasse, die in einer eigenen Datei steht;
- Zeilen 41–42: ein parameterloser Konstruktor, der die Felder bei ihren Anfangswerten belässt.
Ergebnisse:
Zeile 4 der Ergebnisse zeigt, dass der Aufruf von [p.setAge(-4)] (Zeile 8) von der Änderungsmethode abgelehnt wurde. Zeilen 13–16: Eine Instanz wird mit dem parameterlosen Konstruktor erzeugt und dann über ihre Setter initialisiert. Zeilen 19–21: Der Name, der ein Leerzeichen enthält, wird abgelehnt (Zeile 6 der Ergebnisse).
Anders als andere Sprachen hat Java keinen Objektinitialisierer – eine Syntax, die es erlauben würde, mehrere Felder im [new]-Ausdruck selbst zu setzen: Stattdessen verketten wir, wie hier gezeigt, Konstruktor- und Setter-Aufrufe, oder wir schreiben einen Konstruktor, der alle Werte entgegennimmt. Wir betrachten noch zwei weitere Lösungen: „fluide“ Änderungsmethoden und Records.
4.1.16. Finale Felder und erforderliche Parameter
Ein als [final] deklariertes Feld muss genau einmal einen Wert erhalten – entweder bei der Deklaration oder in jedem Konstruktor – und kann danach nicht mehr verändert werden. Der Compiler erzwingt diese Regel. In Kombination mit dem Fehlen von Änderungsmethoden ermöglicht dies die Erzeugung schreibgeschützter Daten. Das Programm [Classes08.java] demonstriert mehrere Fälle:
- Zeilen 28 und 43–49: Der Vorname ist sowohl les- als auch schreibbar; er hat einen Getter und einen Setter;
- Zeilen 30–31: Nachname und Stadt sind [final]-Felder. Der Konstruktor weist ihnen einen Wert zu (Zeilen 37 und 39), der danach nicht mehr geändert werden kann;
- Zeile 32 und Zeilen 56–58: Das Alter ist für alle lesbar, hat aber keinen öffentlichen Setter; es kann nur von Methoden der Klasse verändert werden, etwa von [growOlder] (Zeilen 70–72);
- Zeilen 65–67: Die Methode [getIdentity] gibt einen aus den Feldern berechneten Wert zurück. Für den Benutzer der Klasse ist sie von einer Zugriffsmethode nicht zu unterscheiden;
- Zeilen 11–13: drei Anweisungen, die der Compiler aus den in den Kommentaren genannten Gründen ablehnt. Bei der dritten lautet die Meldung des Compilers: [cannot assign a value to final variable city];
- Zeilen 75–98: Die Klasse [Contact] hat ein Pflichtfeld – die E-Mail-Adresse – und ein optionales Feld – das Telefon. Das Pflichtfeld wird vom Konstruktor erzwungen: Ein [Contact]-Objekt kann nicht ohne E-Mail-Adresse erzeugt werden. Die Methode [Objects.requireNonNull(value, message)] (Zeile 82) gibt ihren ersten Parameter zurück, wenn er nicht [null] ist, und löst andernfalls eine [NullPointerException] mit der angegebenen Meldung aus: Eine E-Mail-Adresse der Form [null] wird abgelehnt (Zeilen 18–23);
- Zeilen 87–89: Die Optionalität der Telefonnummer wird durch einen zweiten Konstruktor ausgedrückt, der einen Standardwert liefert. Java kennt keine optionalen Parameter: Wir überladen den Konstruktor.
Beachten Sie, dass in einer kompakten Datei die Methode [main] Zugriff auf die privaten Felder der Klassen der Datei hat: Deshalb stützen sich die Kommentare in den Zeilen 11–13 nicht auf die Privatheit der Felder, sondern auf das Fehlen einer Änderungsmethode und auf das Schlüsselwort [final].
Ergebnisse:
4.1.17. Fluide Änderungsmethoden
Hat ein Objekt viele optionale Felder, steigt die Zahl der Konstruktoren, und die Aufrufe der Änderungsmethoden werden länger. Eine gängige Technik besteht darin, dass jede Änderungsmethode das aktuelle Objekt ([this]) zurückgibt: Die Aufrufe lassen sich dann verketten; man spricht von „fluiden“ Methoden. Das Programm [Classes09.java] veranschaulicht dies:
- Zeilen 25–28: Die Änderungsmethode [setFirstName] prüft den empfangenen Wert, weist ihn dem Feld zu und gibt das aktuelle Objekt zurück. Ihr Rückgabetyp ist daher [Person];
- Zeile 3: Die Aufrufe werden verkettet: [new Person()] gibt eine Person zurück, auf der [setFirstName] aufgerufen wird, was dieselbe Person zurückgibt, auf der [setLastName] aufgerufen wird, und so weiter. Die Syntax ähnelt einem Objektinitialisierer;
- Zeilen 49–54: Die identischen Prüfungen für Vor- und Nachname sind in die private Methode [check] ausgelagert. Sie ist als [static] deklariert, weil sie keine Felder des Objekts verwendet (statische Member werden im folgenden Absatz behandelt). Die Methode [strip] (Java 11) entfernt führende und nachgestellte Leerzeichen aus der Zeichenkette.
Ergebnisse:
Der Vorname „jean“, der mit Leerzeichen auf beiden Seiten übergeben wurde (Zeile 3), wurde ohne sie gespeichert (Zeile 2 der Ergebnisse). Fluide Änderungsmethoden folgen nicht der JavaBeans-Konvention, nach der eine Änderungsmethode nichts zurückgibt ([void]): Manche Bibliotheken erkennen sie nicht. Zur Konstruktion komplexer Objekte verwendet man auch das Entwurfsmuster „Builder“: Eine Hilfsklasse, ausgestattet mit fluiden Methoden, sammelt die Werte und erzeugt dann das endgültige Objekt, das anschließend unveränderlich sein kann.
4.1.18. Klassenmethoden und Klassenattribute
Angenommen, wir wollen die Anzahl der in einer Anwendung erzeugten [Person]-Objekte zählen. Wir könnten selbst einen Zähler verwalten, riskieren aber, temporäre Objekte zu übersehen, die hier und da erzeugt werden. Sicherer erscheint es, in die Konstruktoren der Klasse [Person] eine Anweisung aufzunehmen, die einen Zähler erhöht. Dieser Zähler kann kein gewöhnliches Feld sein, da jedes Objekt seine eigenen Felder hat: Er ist ein Feld der Klasse selbst und nicht das einer bestimmten Instanz dieser Klasse. Er wird mit dem Schlüsselwort [static] deklariert: [private static long nbPersons;].
Um darauf zu verweisen, schreiben wir [Person.nbPersons] , um anzuzeigen, dass es sich um ein Feld der Klasse [Person] handelt selbst. Hier haben wir ein privates Feld erstellt, auf das von außerhalb der Klasse nicht direkt zugegriffen werden kann. Wir erstellen daher einen öffentlichen Accessor, der den Zugriff auf das Klassenfeld ermöglicht [nbPersons]. Um den Wert von [nbPersons] abzurufen, benötigt dieser Accessor kein bestimmtes [Person] Objekt; daher deklarieren wir ihn zusätzlich als *[static]. Von außen wird er mit der Syntax [Person.getNbPersons()]. Hier ein Beispiel: [Classes10.java]*:
- Zeile 16: das Klassenfeld. Wie jedes numerische Feld wird es mit 0 initialisiert;
- Zeilen 19–21: der Klassen-Accessor;
- Zeilen 24–26: eine Klassenmethode. Sie wird über den Klassennamen aufgerufen: [Person.unknown()] (Zeile 8). Eine Klassenmethode hat kein aktuelles Objekt: Das Schlüsselwort [this] ist dort bedeutungslos, und sie kann direkt nur auf die [static]-Mitglieder der Klasse zugreifen. Eine statische Methode, die ein Objekt ihrer eigenen Klasse erzeugt und zurückgibt, wie diese hier, nennt man Static Factory (statische Fabrikmethode);
- Zeile 38: Der primäre Konstruktor erhöht den Zähler. Der Kopierkonstruktor, der mit dem primären Konstruktor verkettet ist, erhöht ihn daher ebenfalls;
- Zeile 14: Die Klasse [Person] wird als [static] deklariert. Wie im Abschnitt über kompakte Dateien erläutert: Eine in einer kompakten Datei deklarierte Klasse ist eine verschachtelte Klasse der impliziten Klasse. Ohne das Schlüsselwort [static] wäre sie eine innere Klasse, in der jedes Objekt an ein Objekt der umschließenden Klasse gebunden ist; die statische Methode [unknown], die kein aktuelles Objekt hat, könnte keines erzeugen, und der Compiler würde den Fehler [non-static variable this cannot be referenced from a static context] melden. Eine Klasse in einer eigenen Datei hat dieses Problem nicht.
Ergebnisse:
Das Programm hat das in Zeile 5 erzeugte temporäre Objekt korrekt mitgezählt. Wir verwenden Klassenmitglieder von Anfang an: [IO.println], [Integer.parseInt], [Math.sqrt] sind [static]-Methoden, und [Math.PI] ist ein [static]-Feld. Die Klasse [Math] enthält ausschließlich statische Mitglieder: Sie ist als [final] deklariert, und ihr einziger Konstruktor ist privat, was die Erzeugung von Instanzen verhindert. So schreibt man in Java eine Hilfsklasse (Utility-Klasse).
4.1.19. Ein Array von Personen
Ein Objekt ist ein Datum wie jedes andere, und als solches lassen sich mehrere Objekte in einem Array zusammenfassen [Classes11.java]:
- Zeile 3: erzeugt ein Array mit 3 Elementen vom Typ [Person]. Diese 3 Elemente werden hier mit dem Wert [null] initialisiert, das heißt, sie verweisen auf keine Objekte. Genau genommen spricht man von einem „Array von Objekten“, obwohl es sich in Wirklichkeit nur um ein Array von Objektreferenzen handelt. Die Erzeugung des Arrays – das selbst ein Objekt ist (wie [new] anzeigt) – erzeugt keine Objekte vom Typ seiner Elemente; dies muss anschließend geschehen;
- Zeilen 4–6: Erzeugung der 3 Objekte vom Typ [Person];
- Zeilen 8–10: Anzeige des Inhalts des Arrays [friends].
Ergebnisse:
4.1.20. Typinferenz und Array-Initialisierung
Das Programm [Classes12.java] enthält zwei Konstrukte, die die Erzeugung von Objekten und Arrays vereinfachen:
- Zeile 4: Mit dem Schlüsselwort [var] (Java 10) wird der Typ der lokalen Variablen aus dem Ausdruck abgeleitet, der sie initialisiert, hier [Person]. Die Variable ist dennoch typisiert: [p1] ist vom Typ [Person] und kann nur auf eine einzelne Person verweisen. [var] kann nur für lokale Variablen verwendet werden, die bei der Deklaration initialisiert werden, nicht für Felder oder Parameter;
- Zeilen 10–15: ein Array, das mit einer in geschweiften Klammern stehenden, durch Kommas getrennten Liste von Werten erzeugt und befüllt wird. Die Größe des Arrays entspricht der Anzahl der Werte. Ein abschließendes Komma (Zeile 14) ist erlaubt: Es erleichtert das Hinzufügen eines Elements. Diese Syntax ist nur in der Array-Deklaration erlaubt;
- Zeile 16: [var] innerhalb einer [for]-Schleife;
- Zeile 20: Außerhalb einer Array-Deklaration wird ein initialisiertes Array erzeugt, indem man seinen Typ angibt: [new Person[] { ... }]. Man nennt dies ein anonymes Array: Es wird von keiner Variablen in der Methode [main] referenziert;
- Zeilen 24–28: Eine Methode in der kompakten Datei, die ein Array von Personen entgegennimmt.
Ergebnisse:
4.2. Vererbung anhand eines Beispiels
4.2.1. Überblick
Hier führen wir das Konzept der Vererbung ein. Der Zweck der Vererbung besteht darin, eine bestehende Klasse so „anzupassen“, dass sie unseren Anforderungen entspricht. Angenommen, wir möchten eine Klasse [Teacher] erstellen: Ein Lehrer ist eine besondere Art von Person. Er hat Attribute, die andere Personen nicht haben: zum Beispiel das Fach, das er unterrichtet. Aber er hat auch die Attribute, die allen Personen gemeinsam sind: Vorname, Nachname und Alter. Ein Lehrer ist also ein vollwertiges Mitglied der Klasse [Person], aber er hat zusätzliche Attribute. Anstatt eine Klasse [Teacher] von Grund auf neu zu erstellen, bauen wir lieber auf der bestehenden Klasse [Person] auf und passen sie an die Besonderheiten von Lehrern an. Dies ermöglicht das Konzept der Vererbung.
Um anzugeben, dass die Klasse [Teacher] von der Klasse [Person] erbt, schreiben wir [public class Teacher extends Person].
[Person] heißt Elternklasse (oder Basisklasse bzw. Oberklasse), und [Teacher] heißt abgeleitete Klasse (oder Kindklasse bzw. Unterklasse). Ein [Teacher]-Objekt besitzt alle Eigenschaften eines [Person]-Objekts: Es hat dieselben Felder und Methoden. Diese Felder und Methoden der Elternklasse werden in der Definition der Kindklasse nicht wiederholt; wir geben lediglich die Felder und Methoden an, die die Kindklasse hinzufügt. Eine Java-Klasse kann nur von einer Elternklasse erben.
Die Beispiele in diesem Absatz sind zwei Programme aus mehreren Dateien, die in den Ordnern [Inheritance1] und [Inheritance2] liegen. Im Ordner [Inheritance1] ist die Klasse [Person] wie folgt definiert: [Person.java]:
- Zeile 3: der Personenzähler aus dem vorherigen Absatz;
- Zeilen 11–17: Der Konstruktor initialisiert das Objekt über seine Setter, erhöht den Zähler und zeigt eine Fortschrittsmeldung an;
- Zeilen 38–51: drei Setter, die ihre Werte validieren. Die Validierungen für Vor- und Nachname, die identisch sind, wurden in die private Klassenmethode [check] (Zeilen 59–64) ausgelagert. Die Setter sind als [final] deklariert, weil der Konstruktor sie aufruft (siehe das Programm [Classes07.java]);
- Zeilen 54–56: Die Methode [identify] aus den vorherigen Beispielen wurde durch die Methode [getIdentity] ersetzt, die die Identität der Person zurückgibt, anstatt sie anzuzeigen.
Wir erstellen eine Klasse namens [Teacher], die von der Klasse [Person] erbt: [Teacher.java]:
Die Klasse [Teacher] ergänzt die Felder und Methoden der Klasse [Person] um Folgendes:
- Zeile 1: Die Klasse [Teacher] ist von der Klasse [Person] abgeleitet;
- Zeile 3: ein Feld [section], nämlich die Nummer der Sektion, zu der der Lehrer innerhalb des Lehrkörpers gehört (in etwa eine Sektion pro Fach);
- Zeilen 6–13: ein Konstruktor, der alle Felder eines Lehrers initialisiert;
- Zeilen 16–22: der Getter und der Setter für das Feld [section].
4.2.2. Erzeugen eines Teacher-Objekts
Eine Kindklasse erbt die Konstruktoren ihrer Elternklasse nicht. Sie muss eigene Konstruktoren definieren. Der Konstruktor der Klasse [Teacher] lautet wie folgt:
Der Konstruktor erhält vier Parameter ([firstName], [lastName], [age], [section]) und reicht drei davon ([firstName], [lastName], [age]) an seine Elternklasse weiter – hier die Klasse [Person] – und zwar mit der Anweisung [super(firstName, lastName, age);] (Zeile 3). Wir wissen, dass diese Klasse einen Konstruktor [Person(String, String, int)] besitzt, der verwendet wird, um eine Person mit den übergebenen Parametern zu erzeugen. Sobald die Konstruktion des [Person]-Teils abgeschlossen ist, wird die Konstruktion des Objekts [Teacher] fortgesetzt, indem der Rest des Konstruktors (Zeilen 5–7) ausgeführt wird.
Zusammengefasst tut der Konstruktor einer abgeleiteten Klasse Folgendes:
- Er übergibt seiner Elternklasse über [super(...)] die Parameter, die diese zu ihrer eigenen Konstruktion benötigt;
- Er verwendet die übrigen Parameter, um seine eigenen Felder zu initialisieren.
Wir hätten uns auch dafür entscheiden können, die Felder [firstName], [lastName] und [age] direkt im Konstruktor der Klasse [Teacher] mit Anweisungen wie [this.firstName = firstName;] zu initialisieren. Das ist aus zwei Gründen nicht möglich. Erstens sind die privaten Felder [firstName], [lastName] und [age] nur für Methoden der Klasse [Person] zugänglich. Alle anderen Objekte, einschließlich Objekten abgeleiteter Klassen wie hier, müssen über öffentliche (oder geschützte) Mitglieder darauf zugreifen. Anders wäre es, wenn die Klasse [Person] diese Felder als protected deklariert hätte (*[protected]*): Dann könnten abgeleitete Klassen direkt darauf zugreifen. Außerdem muss der [Person]-Teil des Objekts ohnehin von einem Konstruktor der Klasse [Person] erzeugt werden: Fehlt ein Aufruf von [super(...)], fügt der Compiler einen Aufruf von [super()] ein, dem parameterlosen Konstruktor der Elternklasse. Die Klasse [Person] hat jedoch keinen. Wird die Anweisung [super(firstName, lastName, age);] entfernt, meldet der Compiler folgenden Fehler:
Die Verwendung des Konstruktors der Elternklasse ist daher die richtige Lösung und das übliche Vorgehen: Beim Erzeugen eines Kindobjekts ruft man zuerst den Konstruktor des Elternobjekts auf und vervollständigt dann die Initialisierungen, die dem Kindobjekt eigen sind ([section] in unserem Beispiel). Wie bei [this(...)] dürfen dem Aufruf von [super(...)] nur Anweisungen vorausgehen, die das zu konstruierende Objekt nicht verwenden (seit Java 25; zuvor musste [super(...)] die erste Anweisung sein).
4.2.3. Geerbte Methoden
Die Klasse [Teacher] definiert keine Methode namens [getIdentity]. Der Ausdruck [e.getIdentity()], wobei [e] ein Lehrer ist, bezieht sich daher auf die Methode [getIdentity], die von der Klasse [Person] geerbt wird: Sie ist öffentlich und wird durch Vererbung zu einer öffentlichen Methode der Klasse [Teacher]. Das Testprogramm [Main.java] im Ordner [Inheritance1] lautet wie folgt:
- Zeile 3: erzeugt einen Lehrer;
- Zeile 5: zeigt die Identität des Lehrers an, ermittelt über die Methode [getIdentity], die von der Klasse [Person] geerbt wurde;
- Zeile 7: die Methode [getSection], die für die Klasse [Teacher] spezifisch ist;
- Zeilen 11–12: Aufruf der Methode [display] (Zeilen 20–22) zuerst mit einem Lehrer und dann mit einer Person. Darauf kommen wir im nächsten Absatz zurück;
- Zeilen 14–15: Aufruf der Methode [toString] für beide Objekte. Auch darauf kommen wir noch zurück.
Ergebnisse:
Wir stellen fest:
- Ein Objekt [Person] (Zeile 2 der Ergebnisse) wurde vor dem Objekt [Teacher] (Zeile 3) erzeugt;
- [e.getIdentity()] lieferte die Identität des [Person]-Teils des Lehrers, ohne dessen Sektion (Zeile 4);
- Der Personenzähler zählt auch den Lehrer mit (Zeile 11): Ein Lehrer ist eine Person.
Um die vollständige Identität eines Lehrers zu erhalten, muss die Klasse [Teacher] eine eigene Methode [getIdentity] definieren. Genau das leistet der Ordner [Inheritance2].
4.2.4. Polymorphie
Betrachten wir eine Klassenhierarchie: C0 ← C1 ← C2 ← … ← Cn, wobei Ci ← Cj angibt, dass die Klasse Cj von der Klasse Ci abgeleitet ist. Das bedeutet, dass die Klasse Cj alle Eigenschaften der Klasse Ci sowie zusätzliche besitzt. Es seien Oi Objekte vom Typ Ci. Es ist zulässig, [Oi = Oj] mit j > i zu schreiben. Denn durch Vererbung besitzt die Klasse Cj alle Eigenschaften der Klasse Ci sowie zusätzliche. Ein Objekt Oj vom Typ Cj enthält daher ein Objekt vom Typ Ci. Die Operation [Oi = Oj] bewirkt, dass die Variable Oi vom Typ Ci auf das Objekt Oj verweist: Über sie kann nur auf die in der Klasse Ci definierten Mitglieder zugegriffen werden.
Die Tatsache, dass eine Variable Oi der Klasse Ci nicht nur auf ein Objekt der Klasse Ci, sondern auf jedes von Ci abgeleitete Objekt verweisen kann, nennt man Polymorphie: die Fähigkeit einer Variablen, auf Objekte unterschiedlichen Typs zu verweisen.
Nehmen wir ein Beispiel und betrachten die Methode [display] aus dem vorherigen Programm:
Wir können ihr entweder eine [Person] oder einen [Teacher] übergeben: Im letzteren Fall erhält der formale Parameter [p], der vom Typ [Person] ist, einen Wert vom Typ [Teacher]. Da der Typ [Teacher] von dem Typ [Person] abgeleitet ist, ist dies zulässig. Die Anweisung [p.getIdentity()] führte hier die Methode [getIdentity] der Klasse [Person] aus, die einzige, die im Programm existiert: Für den Lehrer (Zeile 7 der Ergebnisse) erhalten wir nur die Identität seines „Person“-Teils. Sehen wir, was passiert, wenn die Klasse [Teacher] ihre eigene Methode [getIdentity] hat.
4.2.5. Methodenüberschreibung und dynamisches Binden
Im Ordner [Inheritance2] ist die Klasse [Person] dieselbe wie im Ordner [Inheritance1] mit einer Ergänzung:
- Zeilen 6–10: eine Neudefinition der Methode [toString], die im folgenden Absatz besprochen wird.
In der Klasse [Teacher] wird die Methode [getIdentity] wie folgt neu definiert:
- Zeilen 23–26: Die Methode [getIdentity] überschreibt die Methode der Elternklasse; sie hat denselben Namen, dieselben Parameter und denselben Rückgabetyp. Sie stützt sich auf die Methode [getIdentity] ihrer Elternklasse, die mit [super.getIdentity()] angesprochen wird, um den „Person“-Anteil abzurufen, und ergänzt ihn dann um die Sektion, die für die Klasse [Teacher] spezifisch ist;
- Zeile 23: Die Annotation [@Override] teilt dem Compiler mit, dass die Methode eine Methode der Elternklasse überschreiben soll. Sie ist nicht zwingend, aber dringend empfohlen: Würde die Methode nichts überschreiben (wegen eines Tippfehlers im Namen oder abweichender Parameter), würde der Compiler einen Fehler melden, anstatt stillschweigend eine neue Methode anzulegen;
- Zeile 2: Die Klasse ist final ([final]), worauf wir später genauer eingehen.
Betrachten wir ein Lehrerobjekt [E]. Dieses Objekt enthält in sich ein Objekt [Person]:

Die Methode [getIdentity] ist sowohl in der Klasse [Teacher] als auch in ihrer Elternklasse [Person] definiert. In Java können alle Instanzmethoden, die weder privat noch final sind, überschrieben werden, und die Entscheidung, welche Methode von [p.getIdentity()] ausgeführt wird, fällt zur Laufzeit, anhand des tatsächlichen Typs des Objekts, auf das [p] verweist, und nicht zur Kompilierzeit anhand des deklarierten Typs der Variablen. Man spricht hier von dynamischem Binden. Um [o.m()] auszuführen, sucht die virtuelle Maschine nach einer Methode namens [m] in der folgenden Reihenfolge:
- in der Klasse des Objekts [o];
- in ihrer Elternklasse, sofern sie eine hat;
- in der Elternklasse ihrer Elternklasse, sofern vorhanden;
- und so weiter.
Die Vererbung erlaubt es daher, in der Kindklasse Methoden neu zu definieren, die dieselbe Signatur wie die der Elternklasse haben. Dadurch lässt sich die Kindklasse an ihre eigenen Bedürfnisse anpassen. Das Programm [Main.java] im Ordner [Inheritance2] lautet wie folgt:
Ergebnisse:
Diesmal hat die Methode [display] in Zeile 4 der Ergebnisse den vollständigen Namen des Lehrers korrekt angezeigt. Die Zeilen 9–11 des Programms zeigen, dass der Lehrer ein Lehrer bleibt, ob man ihn über eine Variable vom Typ [Person] betrachtet oder durch den Operator [(Person)] in [Person] umwandelt: Ausgeführt wird immer noch die Methode [getIdentity] der Klasse [Teacher] (Zeilen 7–8 der Ergebnisse). Die Umwandlung ändert den Typ der Referenz, nicht den des Objekts. Anders als in anderen Sprachen wie C#, wo eine Methode nur überschrieben werden kann, wenn sie als virtual deklariert ist, sind Java-Methoden standardmäßig „virtuell“; ein Überschreiben von Instanzmethoden ohne dynamisches Binden gibt es nicht.
4.2.6. Die Klasse Object und die Methode toString
Die Klasse [java.lang.Object] ist die „Elternklasse“ aller Java-Klassen. Wenn Sie also [public class Person] schreiben, schreiben Sie implizit [public class Person extends Object].
Die Klasse [Object] definiert mehrere Methoden, die alle Objekte erben:
- [String toString()]: liefert eine textuelle Darstellung des Objekts. Standardmäßig ist dies der Klassenname des Objekts, gefolgt vom Zeichen [@] und einem hexadezimal geschriebenen Hashcode;
- [boolean equals(Object o)]: gibt an, ob das Objekt dem Objekt [o] „gleich“ ist. Standardmäßig ist es nur sich selbst gleich: Die Methode vergleicht Referenzen, wie der Operator [==];
- [int hashCode()]: liefert einen Hashcode für das Objekt, den Dictionaries und Mengen verwenden (siehe nächstes Kapitel). Die Methoden [equals] und [hashCode] werden später besprochen;
- [Class<?> getClass()]: liefert die Beschreibung der tatsächlichen Klasse des Objekts. Die Methode [getSimpleName] dieser Beschreibung liefert den Klassennamen, während [getName] liefert den vollständigen Namen.
Es ist die Methode [toString] der Klasse [Object] , die von den Aufrufen [e.toString()] und [p.toString()] im Ordner [Inheritance1] verwendet wurde: [Teacher@70325e14] und [Person@37ceb1df] (Zeilen 9–10 der Ergebnisse; die Zahlen variieren von Ausführung zu Ausführung). Obwohl wir die Methode [toString] in den Klassen [Person] und [Teacher] nicht neu definiert haben, konnte die Methode [toString] der Klasse [Object] den tatsächlichen Klassennamen des Objekts anzeigen.
Im Ordner [Inheritance2] definiert die Klasse [Person] die Methode [toString] neu (siehe oben). Kehren wir zum Programm [Main.java] im Ordner [Inheritance2] zurück:
Zeile 2: Die Methode [IO.println(Object)] akzeptiert einen Parameter vom Typ [Object]; da [Object] die Oberklasse aller Klassen ist, kann daher jedes Objekt – hier ein [Teacher] – übergeben werden. Sie gibt das Ergebnis der Methode [toString] des Objekts auf der Konsole aus. Da das Binden dynamisch erfolgt, wird die Methode [toString] des tatsächlichen Objekts verwendet – hier die von der Klasse [Person] geerbte. Diese liefert [getIdentity()], eine neu definierte Methode: Für den Lehrer [e] wird daher die Methode [getIdentity] der Klasse [Teacher] ausgeführt, wie Zeile 9 der Ergebnisse zeigt. Es ist daher nicht nötig, [toString] in der Klasse [Teacher] neu zu definieren.
Derselbe Mechanismus gilt für die Verkettung einer Zeichenkette mit einem Objekt: In [" : " + person] (Zeile 7) wird das Objekt [person] durch seine Methode [toString] in eine Zeichenkette umgewandelt. Die Schleife in den Zeilen 6–8 durchläuft ein Array von Referenzen [Person], die tatsächlich auf Objekte unterschiedlichen Typs verweisen: [getClass().getSimpleName()] liefert den tatsächlichen Klassennamen jedes Objekts (Zeilen 11–12 der Ergebnisse).
4.2.7. Finale Klassen und versiegelte Klassen
Die Klasse [Teacher] im Paket [Inheritance2] ist als [public final class Teacher extends Person] deklariert. Das Schlüsselwort [final] verhindert, dass von der Klasse [Teacher] Klassen abgeleitet werden: Die Deklaration [class TeacherResearcher extends Teacher] würde vom Compiler abgelehnt. Eine Klasse wird als final gekennzeichnet, wenn von ihr nicht abgeleitet werden soll. Wir haben gesehen, dass das Schlüsselwort auch für Methoden gilt: Eine [final]-Methode kann von abgeleiteten Klassen nicht überschrieben werden, wobei die Klasse selbst ableitbar bleibt. Beispielsweise ist die Klasse [String], die aus dem JDK stammt, final.
Zwischen einer für alle Ableitungen offenen Klasse und einer finalen Klasse hat Java 17 eine Zwischenlösung eingeführt: die versiegelte Klasse ([sealed]), die eine abschließende Liste ihrer direkt abgeleiteten Klassen angibt. Das Programm [Classes13.java] veranschaulicht dies:
- Zeile 20: Die abstrakte Klasse (siehe unten: Von dieser Klasse können keine Objekte erzeugt werden, nur von ihren abgeleiteten Klassen) [Person] ist versiegelt. Nur die Klassen [Teacher], [Student], und [Adjunct], die nach dem Schlüsselwort [permits] aufgeführt sind, dürfen von ihr abgeleitet werden. Werden abgeleitete Klassen in derselben Datei deklariert, wie hier, kann die Klausel [permits] entfallen: Die zugelassenen Klassen sind dann diejenigen der Datei, die direkt von ihr abgeleitet sind. In einem größeren Programm müssen die zugelassenen Klassen zum selben Paket wie die versiegelte Klasse gehören (oder zum selben Modul, wenn die versiegelte Klasse zu einem benannten Modul gehört);
- Zeile 24: Der Konstruktor ist geschützt ([protected]): Er ist nur für abgeleitete Klassen gedacht;
- Zeilen 35 und 49: Eine von einer versiegelten Klasse abgeleitete Klasse muss angeben, wie sie selbst abgeleitet werden kann. Die Klassen [Teacher] und [Student] sind final;
- Zeile 64: Die Klasse [Adjunct] wird als [non-sealed] deklariert: Dies öffnet die Hierarchie wieder und erlaubt es jeder beliebigen Klasse, von ihr abzuleiten. Eine dritte Möglichkeit besteht darin, sie selbst als [sealed] zu deklarieren, mit einer eigenen Liste zugelassener Klassen;
- Zeilen 71–83: Die Klasse [Consultant] wird von [Adjunct] abgeleitet, was erlaubt ist;
- Zeilen 85–86: eine Klasse [Artist] , abgeleitet von [Person] , würde abgelehnt;
- Zeilen 13–16: Die Beschreibung einer Klasse ([Person.class]) gibt an, ob sie versiegelt ist ([isSealed]), und listet ihre zugelassenen direkt abgeleiteten Klassen auf ([getPermittedSubclasses]).
Ergebnisse:
Wenn Sie die Klasse [Artist] wieder einkommentieren (indem Sie ihr einen Konstruktor hinzufügen), meldet der Compiler:
Wozu dient eine versiegelte Klasse? Sie erlaubt es dem Autor einer Klassenhierarchie, die Kontrolle über sie zu behalten: Er weiß, dass jede [Person] entweder ein [Teacher], ein [Student], oder ein [Adjunct] ist. Auch der Compiler weiß dies und nutzt es beim Pattern Matching, das am Ende des Kapitels behandelt wird: Ein [switch] , der alle drei Fälle abdeckt, ist vollständig. Der Mechanismus gilt auch für Schnittstellen ([sealed interface]), die später behandelt werden.
4.3. Kein Operator-Overloading: equals, compareTo …
Einige Sprachen wie C# oder C++ erlauben es, die Bedeutung von Operatoren ([+], [==], [<] …) für eine Klasse neu zu definieren. Java erlaubt dies nicht: Operatoren haben immer die ihnen von der Sprache zugewiesene Bedeutung. Die einzige Ausnahme ist der Operator [+] bei Anwendung auf eine Zeichenkette, der eine Verkettung durchführt und dazu die Methode [toString] des verketteten Objekts verwendet. Anstelle von Operatoren schreiben wir Methoden, die bewährten Konventionen folgen:
Operation | Java-Methode | Beispiel |
Inhaltsgleichheit ([==] vergleicht Referenzen) | [boolean equals(Object o)], geerbt von [Object] | [s1.equals(s2)] |
Vergleich ([<], [>] …) | [int compareTo(T other)] aus der Schnittstelle [Comparable<T>]: negatives, Null- oder positives Ergebnis | [s1.compareTo(s2) < 0] |
arithmetische Operationen | explizit benannte Methoden | [a.add(b)], [a.multiply(b)] für [BigDecimal] |
Hinzufügen zu einer Collection ([+=]) | [add] | [list.add(p)] |
4.3.1. Ein Beispiel
Der Ordner [Lists] enthält eine Klasse [ListOfPersons], eine Liste von Personen, deren Methoden als die Operatoren [+] und [+=] fungieren. Die Klassen [Person] und [Teacher] in diesem Ordner sind vereinfachte Versionen derjenigen im Ordner [Inheritance2]: Die Felder sind [final] und haben keine Setter; es gibt keine Verfolgungsmeldungen und keine Zähler mehr. Die Personen sind in einer generischen Liste [List<Person>] organisiert (generische Klassen werden später in diesem Kapitel behandelt; Listen werden im nächsten Kapitel behandelt). Anstatt die Klasse [ListOfPersons] von einer Listenklasse des JDK erben zu lassen, legen wir die Liste in einem privaten Feld der Klasse ab. Man spricht hier von Komposition statt Vererbung: Die Klasse [ListOfPersons] stellt so nur die Operationen bereit, die sie gewählt hat. Von der Schnittstelle [List<Person>] verwenden wir nur die folgenden Elemente:
- die Methode [l.add(p)], die die Person [p] zur Liste [l] hinzufügt, und die Methode [l.addAll(l2)], die alle Elemente der Liste [l2] zu ihr hinzufügt;
- die Methode [l.size()], die die Anzahl der Elemente der Liste [l] zurückgibt;
- die Methoden [l.get(i)] und [l.set(i, p)], die das Element Nummer i der Liste [l] lesen und ändern.
Die Definition der Klasse [ListOfPersons] lautet wie folgt: [ListOfPersons.java]:
- Zeilen 1–3: Anders als die kompakte Datei [Main.java] importiert eine reguläre Datei die Klassen des Moduls [java.base] nicht automatisch: Sie muss die verwendeten Klassen importieren (außer denen aus dem Paket [java.lang], wie [String], die immer bekannt sind). Die [import]-Klauseln werden zusammen mit den Paketen angegeben;
- Zeile 7: die Liste der Personen. Das Schlüsselwort [final] gibt an, dass das Feld immer auf dieselbe Liste verweist; der Inhalt der Liste selbst kann sich ändern. [new ArrayList<>()] erzeugt eine leere Liste; der „Diamond“-Operator [<>] ermöglicht es dem Compiler, den Typ der Elemente, [Person], aus dem Feldtyp abzuleiten;
- Zeilen 10–12: die Anzahl der Personen;
- Zeilen 16–21: Die Methode [plus] fungiert als [+]-Operator für die Operation [l.plus(p)], wobei [l] vom Typ [ListOfPersons] ist und [p] vom Typ [Person] oder einer davon abgeleiteten Klasse. Sie erzeugt eine neue Liste (Zeile 17), kopiert die Personen der aktuellen Liste hinein (Zeile 18) und fügt dann die Person [p] hinzu (Zeile 19). Wie beim Operator [+] für Zahlen oder Zeichenketten werden die Operanden nicht verändert. Da die Liste [result] von derselben Klasse ist, hat die Methode Zugriff auf ihr privates Feld [result.persons]. Die zurückgegebene Liste ist vom Typ [ListOfPersons], was verkettete Aufrufe wie in [l.plus(p1).plus(p2)] ermöglicht;
- Zeilen 24–27: Die Methode [add] fungiert als [+=]-Operator: Sie ändert die aktuelle Liste, indem sie die Person [p] hinzufügt, und gibt dieselbe Liste zurück, was ebenfalls verkettete Aufrufe erlaubt;
- Zeilen 49–56: Wir definieren die Methode [toString] neu, um eine Liste von Personen in der Form (person1, person2, ...) anzuzeigen, wobei personi selbst das Ergebnis der Methode [toString] der Person ist. Ein Objekt [StringJoiner] (Zeile 51) erzeugt aus aufeinanderfolgenden Elementen ([add], Zeile 53) eine Zeichenkette, trennt sie mit dem angegebenen Trennzeichen (hier einem Komma) und schließt sie mit einem Präfix und einem Suffix ein (hier Klammern).
Beachten Sie, dass die Klasse [ListOfPersons] keinen Konstruktor hat. Sie verwendet daher den Standardkonstruktor, der keine Parameter hat und nichts anderes tut, als das Feld [persons] mit dem in seiner Deklaration angegebenen Wert zu initialisieren. Die Zeilen 29–46 werden im folgenden Abschnitt behandelt.
Das Testprogramm [Main.java] beginnt wie folgt:
- Zeilen 3–5: zwei Zeichenketten mit gleichem Inhalt, aber verschiedene Objekte: Die Zeichenkette [s2] wird zur Laufzeit erzeugt. Der Operator [==] vergleicht die Referenzen, während die Methode [equals] die Inhalte vergleicht. Zum Vergleich zweier Zeichenketten muss man immer [equals] verwenden;
- Zeile 6: Die Methode [compareTo] liefert eine negative Zahl, weil „jean“ in der Zeichencode-Reihenfolge vor „paul“ steht;
- Zeilen 7–8: Die Klasse [BigDecimal] (exakte Dezimalzahlen, die wir für die Beträge verwenden werden) ersetzt die Operatoren [+] und [<] durch die Methoden [add] und [compareTo];
- Zeile 12: Erzeugung einer leeren Liste von Personen [l];
- Zeile 14: Hinzufügen von zwei Personen mit der Methode [plus];
- Zeile 18: [l.plus(p)] erzeugt eine neue Liste, [l2]; die Liste [l] bleibt unverändert;
- Zeile 25: fügt mit der Methode [add] einen Lehrer hinzu;
- Zeilen 16–20: Die Verkettung einer Zeichenkette und eines Objekts verwendet die Methode [toString], die in der Klasse [ListOfPersons] neu definiert wurde.
Ergebnisse (Anfang):
Warum gibt es zwei Methoden, wenn [l = l.plus(p)] dieselbe Ausgabe erzeugt wie [l.add(p)]? Die Methode [plus] erzeugt eine neue Liste, kopiert alle Personen aus [l] hinein, und anschließend verweist [l] auf diese neue Liste, während die alte vom Garbage Collector verworfen wird. Die Methode [add] fügt die Person zur bestehenden Liste hinzu, ohne sie zu kopieren. Zeile 23 speichert eine zweite Referenz, [l3], auf die Liste [l]; nach dem Aufruf von [l.add(...)], verweisen beide Referenzen weiterhin auf dasselbe Objekt (Zeile 9 der Ergebnisse), was beweist, dass die Liste nicht neu erzeugt wurde. Bei einer großen Liste oder innerhalb einer Schleife ist der Leistungsunterschied erheblich. Die Wahl zwischen den beiden Stilen zeigt sich im JDK deutlich: Die unveränderlichen Objekte [String] und [BigDecimal] geben neue Objekte zurück; Listen und [StringBuilder] werden verändert.
4.4. Keine Indexer: get- und set-Methoden
Hier verwenden wir weiterhin die Klasse [ListOfPersons]. Wenn [l] ein [ListOfPersons]-Objekt ist, möchten wir auf die Person mit dem Index i in der Liste [l] sowohl lesend als auch schreibend zugreifen können. Einige Sprachen erlauben es, dafür einen „Indexer“ zu definieren, der die Notation [l[i]] für ein Objekt ermöglicht. Java erlaubt das nicht: Die Notation [[i]] ist Arrays vorbehalten. Per Konvention schreiben wir die Methoden [get(int i)] und [set(int i, value)], genau wie die Listen des JDK:
- Zeilen 2–4: Die Methode [get] liefert die Person Nr. i aus der privaten Liste [persons];
- Zeilen 6–8: Die Methode [set] weist ihr die Person [p] zu;
- Zeilen 11–18: Wir möchten außerdem die Position der Person mit einem bestimmten Namen in der Liste ermitteln können, oder -1, wenn diese Person nicht in der Liste enthalten ist. Der Name [indexOf] ist der der entsprechenden Methode für Listen und Zeichenketten im JDK. Die Namen werden mit [equals] verglichen (Zeile 13).
Das Testprogramm wird wie folgt fortgesetzt:
- Zeile 3: Aufruf der Methode [set];
- Zeile 5: Aufruf der Methode [get];
- Zeile 11: Aufruf der Methode [indexOf];
- Zeile 13: Aufruf der Methode [get].
Ergebnisse (Ende):
4.5. Keine Strukturen: primitive Typen und Records
4.5.1. Wert und Referenz
Andere Sprachen wie C oder C# bieten neben Klassen auch Strukturen: Typen, deren Variablen die Daten direkt enthalten und nicht eine Referenz auf ein Objekt. Java kennt sie nicht. Es unterscheidet zwei Familien von Typen:
- die acht primitiven Typen ([byte], [short], [int], [long], [float], [double], [char], [boolean]): Eine Variable eines primitiven Typs enthält den Wert selbst;
- Referenztypen: Klassen (einschließlich [String]), Schnittstellen, Arrays, Records usw. Eine Variable eines Referenztyps enthält eine Referenz auf ein Objekt oder [null].
Das Programm [Classes14.java] veranschaulicht den Unterschied:
- Zeilen 37–40: eine Klasse mit zwei Feldern, auf die innerhalb des Pakets zugegriffen werden kann: [name] und [age]. Die nicht privaten Felder – von denen im Allgemeinen abgeraten wird – machen das Beispiel hier leichter lesbar.
Ergebnisse:
Die Deklaration [int age1 = 10;] (Zeile 4) reserviert eine Speicherstelle, die die ganze Zahl 10 enthält: Der Wert von [age1] ist die ganze Zahl selbst. Im Fall der Klasse wird das Objekt ([name], [age]) explizit mit dem Operator [new] (Zeile 13) erzeugt. Das Objekt wird in einem vom Garbage Collector verwalteten Speicherbereich abgelegt, dem Heap, und der Wert von [op1] ist die Adresse (die Referenz) dieses Objekts.
Wenn im Programm [int age2 = age1;] geschrieben wird (Zeile 5), wird der Wert von [age1] – die ganze Zahl 10 – nach [age2] kopiert: Dies ist eine Wertkopie. Eine Änderung von [age2] ändert [age1] nicht (Zeile 3 der Ergebnisse). Betrachten wir nun die Anweisung [CPerson op2 = op1;] (Zeile 18). Der Wert von [op1] wird nach [op2] kopiert, aber da dieser Wert die Adresse des Objekts ist, wird das Objekt selbst nicht dupliziert: [op1] und [op2] verweisen auf dasselbe Objekt. Wird das Objekt, auf das [op2] verweist, geändert, ändert sich auch das Objekt, auf das [op1] verweist, da es dasselbe ist (Zeilen 6–7 der Ergebnisse). Um ein zweites Objekt zu erhalten, muss man es erzeugen und die Felder des ersten hineinkopieren (Zeilen 28–30): Eine Änderung der Kopie ändert das Original nicht (Zeilen 8–9 der Ergebnisse).

Aus diesen Erläuterungen können wir Folgendes schließen:
- Der Wert einer Variablen eines primitiven Typs sind die Daten selbst;
- der Wert einer Variablen eines Referenztyps ist die Adresse des Objekts, auf das sie verweist;
- Zuweisung und Parameterübergabe kopieren immer den Wert der Variablen: bei einem primitiven Typ die Daten selbst, bei einem Objekt die Referenz.
Jedem primitiven Typ entspricht eine sogenannte „Wrapper“-Klasse im Paket [java.lang]: [Integer] für [int], [Double] für [double], [Boolean] für [boolean] und so weiter. Der Compiler wandelt einen primitiven Wert automatisch in ein Wrapper-Objekt um und umgekehrt („Autoboxing“ und „Unboxing“): Das benötigen wir bei Generics, die nur Referenztypen akzeptieren. Eine Variable [Integer] kann gleich [null] sein, eine Variable [int] hingegen nie.
Um ein kleines zusammengesetztes Datenelement (einen Punkt, eine Farbe, ein Datum, einen Betrag) darzustellen, das wie ein Wert behandelt wird, verwendet Java unveränderliche Klassen: Ihre Objekte können nach ihrer Erzeugung nicht mehr verändert werden. Das Teilen einer Referenz auf ein unveränderliches Objekt ist sicher: Niemand kann es ändern, und das Objekt verhält sich dann wie ein Wert. Zwei Werkzeuge runden dieses System ab: die Methode *[equals]*, die zwei Objekte anhand ihres Inhalts vergleicht, und Records, die eine unveränderliche Klasse in einer einzigen Zeile deklarieren. Dies ist Thema der folgenden beiden Absätze.
4.5.2. Gleichheit zweier Objekte: equals und hashCode
Wie wir gesehen haben, gibt der Operator [==], auf zwei Referenzen angewendet, an, ob sie auf dasselbe Objekt verweisen, und die Methode [equals], geerbt von [Object], tut dasselbe. Damit zwei verschiedene Objekte mit demselben Inhalt als gleich gelten, muss eine Klasse die Methode [equals] neu definieren, und zwingend zusammen mit ihr die Methode [hashCode]. Das Programm [Classes15.java] zeigt dies:
- Zeilen 32–44: Die Methode [equals] überschreibt die der Klasse [Object]. Ihr Parameter ist vom Typ [Object]: Eine Person kann mit jedem beliebigen Objekt verglichen werden. Die Methode folgt einem Standardmuster:
- Zeilen 35–37: Ein Objekt ist gleich sich selbst;
- Zeilen 39–41: Der Ausdruck [o instanceof Person other] (Java 16) ist wahr, wenn [o] auf ein Objekt vom Typ [Person] (oder einer abgeleiteten Klasse) verweist, und falsch andernfalls, insbesondere wenn [o] gleich [null] ist. Ist er wahr, verweist die Variable [other], vom Typ [Person], auf das Objekt [o]: Ihre Felder können verwendet werden. Dieses „Typmuster“ wird am Ende des Kapitels ausführlich erklärt;
- Zeile 43: Die Felder werden verglichen. Die Methode [Objects.equals(a, b)] vergleicht zwei Objekte mit [equals] und behandelt dabei den Fall, dass eines von ihnen [null] ist;
- Zeilen 47–50: Die Methode [hashCode] liefert eine aus denselben Feldern berechnete ganze Zahl, hier mithilfe der Methode [Objects.hash]. Die Regel ist zwingend: Zwei Objekte, die im Sinne von [equals] gleich sind, müssen denselben Hashcode haben. Die Dictionaries und Mengen des JDK (nächstes Kapitel) ordnen Objekte anhand dieses Codes ein und würden nicht mehr funktionieren, wenn die Regel nicht befolgt würde;
- Zeilen 12–17: Eine [HashSet]-Menge enthält nie zwei gleiche Objekte: Das Hinzufügen von [p2], das gleich [p1] ist, hat keine Wirkung, und die Suche nach einer neuen Person ([paul, 10]) ist erfolgreich.
Ergebnisse:
Das manuelle Eingeben von [equals] und [hashCode] ist mühsam und fehleranfällig; Entwicklungsumgebungen können sie generieren. Records hingegen stellen sie automatisch bereit.
4.5.3. Unveränderliche Objekte
Das Programm [Classes16.java] zeigt zwei Möglichkeiten, unveränderliche Daten zu definieren:
- Zeilen 19–45: eine von Hand geschriebene unveränderliche Klasse. Sie ist final, damit keine abgeleitete Klasse veränderlichen Zustand hinzufügen kann; ihre Felder sind privat und [final]; sie hat keine Setter. Um einen Punkt zu „verschieben“, liefert die Methode [move] einen neuen Punkt zurück (Zeilen 37–39);
- Zeile 48: ein Record (Java 16). Der Kopf [record Color(int r, int g, int b)] deklariert eine finale Klasse mit drei privaten Feldern – [final], den sogenannten Record-Komponenten –, einem Konstruktor mit drei Parametern und drei Accessoren: [r()], [g()], [b()], sowie den Methoden [toString], [equals] und [hashCode], die alle die Komponenten verwenden;
- Zeilen 50–56: Sie können einem Record Methoden hinzufügen. Da ein Record unveränderlich ist, kann er nicht geändert werden: Stattdessen wird eine Kopie erzeugt, in der eine Komponente geändert wurde. Diese Methoden heißen „Withers“ (vom englischen „with“); andere Sprachen bieten dafür einen eigenen Ausdruck, [with], der in Java 25 nicht existiert;
- Zeile 11: Ein Accessor für eine Komponente trägt den Namen der Komponente, ohne das Präfix [get];
- Zeile 12: Zwei Records mit denselben Komponenten sind im Sinne von [equals] gleich, auch wenn sie verschieden sind;
- Zeile 14: Die „Wither“-Methoden werden verkettet.
Ergebnisse:
Das generierte [toString] zeigt den Namen des Records und seine Komponenten an (Zeile 3 der Ergebnisse). Beachten Sie hier, dass ein Record die knappste Möglichkeit ist, ein kleines, unveränderliches Datenelement zu deklarieren: Diesen Typ werden wir für die Steuerstufen in der Beispielanwendung dieses Kapitels verwenden. Records werden später ausführlich behandelt.
4.6. Schnittstellen
4.6.1. Ein erstes Beispiel
Eine Schnittstelle ist eine Menge von Methodendeklarationen, die einen Vertrag bildet. Eine Klasse, die sich dafür entscheidet, eine Schnittstelle zu implementieren, verpflichtet sich, eine Implementierung aller in der Schnittstelle definierten abstrakten Methoden bereitzustellen. Der Compiler überprüft diese Implementierung.
Hier ist beispielsweise die (vereinfachte) Definition der Schnittstelle [java.util.Iterator<E>] des JDK, mit der man über die Elemente einer Sammlung iterieren kann: [public interface Iterator<E> { boolean hasNext(); E next(); }]. Die Methoden der Schnittstelle sind nur durch ihre Signaturen definiert, gefolgt von einem Semikolon: Sie haben keinen Code und sind implizit öffentlich und abstrakt. Es sind die Klassen, die die Schnittstelle implementieren, die den Code für ihre Methoden bereitstellen. Eine Klasse namens [C] deklariert mit dem Schlüsselwort [implements], dass sie die Schnittstelle implementiert: [public class C implements Iterator<String>], und sie muss dann die beiden öffentlichen Methoden [public boolean hasNext() { ... }] und [public String next() { ... }] definieren.
Eine verbreitete Konvention (die jedoch nicht allgemein gilt – das JDK befolgt sie nicht) besteht darin, den Namen einer Schnittstelle mit dem Buchstaben I zu beginnen. Die folgenden Beispiele bilden den Ordner [Statistics]. Betrachten Sie die folgende Schnittstelle, [IStats.java]:
Die Schnittstelle [IStats] enthält:
- eine Methode [average]: zur Berechnung des Mittelwerts einer Reihe von Werten;
- eine Methode [standardDeviation]: zur Berechnung der Standardabweichung.
Beachten Sie, dass an keiner Stelle festgelegt ist, auf welche Wertemenge sich dies bezieht. Es könnte der Notendurchschnitt einer Klasse sein, der monatliche Durchschnittsumsatz eines bestimmten Produkts, die Durchschnittstemperatur an einem bestimmten Ort … Das ist das Prinzip hinter Schnittstellen: Wir setzen die Existenz von Methoden im Objekt voraus, nicht aber die bestimmter Daten. Die Methoden haben nicht das Präfix [get]: Es handelt sich um Berechnungen und nicht um Feldzugriffe, und diese Wahl erlaubt es einem Record, die Schnittstelle zu implementieren.
Eine erste Klasse, die die Schnittstelle [IStats] implementiert, könnte eine Klasse sein, die die Noten der Studierenden eines Kurses in einem bestimmten Fach speichert. Ein Studierender wird durch den folgenden Record [Student] charakterisiert, [Student.java]:
Der Studierende wird durch seinen Vor- und Nachnamen identifiziert. Der im vorherigen Absatz gezeigte Record leistet dies in einer einzigen Zeile. Eine Note wird durch den folgenden Record dargestellt, [Grade], der wie folgt aussieht: [Grade.java]:
Die Note wird durch den bewerteten Studierenden und die Note selbst definiert. Der Record definiert die vom Compiler generierte Methode [toString] neu, um eine Note in der Form [firstName,lastName,value] anzuzeigen.
Die Noten aller Studierenden in einem bestimmten Fach werden in der folgenden Klasse zusammengefasst: [ArrayOfGrades]: [ArrayOfGrades.java]:
- Zeile 3: Die Klasse [ArrayOfGrades] implementiert die Schnittstelle [IStats]. Sie muss daher die Methoden [average] und [standardDeviation] implementieren. Diese sind in den Zeilen 39–47 implementiert. Die Annotation [@Override] wird auch beim Implementieren einer Schnittstellenmethode verwendet;
- Zeilen 5–8: vier Felder [final]: das Fach, für das das Objekt Noten speichert, das Notenarray, der Mittelwert und die Standardabweichung der Noten;
- Zeilen 11–27: der Konstruktor. Hier nehmen wir an, dass sich die dem Konstruktor übergebenen Noten danach nicht mehr ändern. Daher verwenden wir den Konstruktor, um Mittelwert und Standardabweichung dieser Noten sofort zu berechnen und zu speichern. Ein [final]-Feld, wie [average], kann im Konstruktor einen Wert erhalten (Zeile 20); danach kann ihm kein Wert mehr zugewiesen werden. Die Ausdrücke [condition ? value1 : value2] setzen Mittelwert und Standardabweichung eines leeren Arrays auf -1. [Math.pow(x, 2)] berechnet x², und [Math.sqrt] berechnet die Quadratwurzel;
- Zeilen 50–53: Die Methode [toString] verwendet die statische Methode [Arrays.toString], die die Elemente eines Arrays in eckigen Klammern, durch Kommas getrennt, zurückgibt, wobei jedes durch seine Methode [toString] in eine Zeichenkette umgewandelt wird, hier die des Records [Grade].
In der vorherigen Klasse wurden die Noten in einem Array gespeichert. Es war nicht möglich, nach der Erzeugung des Objekts [ArrayOfGrades] eine neue Note hinzuzufügen. Wir schlagen nun eine zweite Implementierung der Schnittstelle [IStats] namens [ListOfGrades], vor, bei der die Noten diesmal in einer Liste [List<Grade>] gespeichert werden, mit der Möglichkeit, nach der erstmaligen Erzeugung des Objekts [ListOfGrades] Noten hinzuzufügen: [ListOfGrades.java]:
- Zeile 3: Die Klasse [ListOfGrades] implementiert die Schnittstelle [IStats];
- Zeile 6: Die Noten werden nun in einer Liste statt in einem Array gespeichert;
- Zeilen 27–32: Sie können nun eine Note zu den bereits gespeicherten hinzufügen. Mittelwert und Standardabweichung werden nicht mehr im Konstruktor berechnet, sondern bei Bedarf, innerhalb der Schnittstellenmethoden selbst: [average] (Zeilen 35–41) und [standardDeviation] (Zeilen 44–50). Einmal berechnet, werden diese Werte gespeichert, damit sie nicht bei jeder Anfrage neu berechnet werden: Man sagt, sie werden zwischengespeichert (Cache). Das Hinzufügen einer Note macht den Cache ungültig;
- Zeilen 8–9: der Cache. Der Typ [Double] ist die Wrapper-Klasse des primitiven Typs [double]: Anders als eine Variable vom Typ [double] kann eine Variable vom Typ [Double] den Wert [null] haben, was hier „noch nicht berechnet“ bedeutet. Nicht initialisierte Felder werden bei der Konstruktion des Objekts auf [null] gesetzt;
- Zeilen 38 und 40: Der Compiler wandelt automatisch den [double], den [computeAverage] zurückgibt, in das Objekt [Double] um („Autoboxing“), und das Objekt [Double] für den Rückgabewert der Methode in [double] um („Unboxing“).
Ein Testprogramm könnte wie folgendes [Main.java] aussehen:
- Zeilen 3–5: Erzeugung eines Arrays von Studierenden;
- Zeile 6: Erzeugung eines Arrays von Noten;
- Zeile 8: ein Objekt [ArrayOfGrades], dessen Mittelwert und Standardabweichung in Zeile 10 angezeigt werden;
- Zeile 12: ein Objekt [ListOfGrades], dessen Mittelwert und Standardabweichung in Zeile 13 angezeigt werden. [List.of(grades)] liefert eine schreibgeschützte Liste der Elemente des Arrays; der Konstruktor der Klasse [ArrayList] macht daraus eine veränderbare Liste, zu der Noten hinzugefügt werden können;
- Zeile 15: Eine neue Note wird hinzugefügt, gefolgt von einer Aktualisierung der Anzeige;
- Zeilen 25–27: Die Methode
[displayStats]nimmt als Parameter einen Typ*[IStats]entgegen, der ein Schnittstellentyp ist. Das bedeutet, dass der tatsächliche Parameter jedes Objekt sein kann, das die Schnittstelle*[IStats]implementiert. Bei der Verwendung eines Datenobjekts eines Schnittstellentyps werden nur die Methoden der Schnittstelle verwendet, die vom Datenobjekt implementiert werden. Die übrigen werden ignoriert. Diese Eigenschaft ähnelt der für Klassen besprochenen Polymorphie. Wenn eine Menge von Klassen Ci, die nicht durch Vererbung miteinander verwandt sind (und daher die auf Vererbung beruhende Polymorphie nicht nutzen können), eine Menge von Methoden mit derselben Signatur gemeinsam haben, kann es sinnvoll sein, diese Methoden in einer Schnittstelle I zusammenzufassen, die alle betreffenden Klassen implementieren. Instanzen dieser KlassenCikönnen dann als tatsächliche Parameter für Methoden verwendet werden, die einen formalen Parameter vom TypIakzeptieren – das heißt für Methoden, die nur die in der SchnittstelleIdefinierten Methoden derCi-Objekte verwenden und nicht die spezifischen Felder und Methoden der verschiedenenCi-Klassen; - Zeilen 18–21: Eine Variable kann den Typ einer Schnittstelle haben. Sie kann dann auf jedes Objekt einer Klasse verweisen, die die Schnittstelle implementiert. Der Compiler erlaubt nur den Zugriff auf die Methoden der Schnittstelle (und auf die der Klasse [Object], wie [toString]).
Ergebnisse:
Die Verkettung einer Zahl ([double]) mit einer Zeichenkette verwendet die Methode [Double.toString], die die Zahl unabhängig von den Spracheinstellungen des Arbeitsplatzrechners immer mit Dezimalpunkt und mindestens einer Nachkommastelle schreibt (16.0). Für eine Anzeige mit Dezimalkomma verwenden Sie [String.format("%.2f", x)], wie im folgenden Beispiel.
Beachten Sie schließlich, dass Schnittstellen mehrfach implementiert werden können; man kann also [public class DerivedClass extends BaseClass implements I1, I2, ..., In] schreiben, wobei die Ij Schnittstellen sind: Eine Klasse erbt von nur einer Klasse, kann aber beliebig viele Schnittstellen implementieren. Eine Schnittstelle kann selbst eine oder mehrere andere Schnittstellen erweitern: [interface I3 extends I1, I2].
4.6.2. Default-, statische und private Schnittstellenmethoden
Seit Java 8 kann eine Schnittstelle für einige ihrer Methoden eine Standardimplementierung bereitstellen, die mit dem Schlüsselwort [default] deklariert wird. Eine Klasse, die die Schnittstelle implementiert, kann diese Implementierung dann verwenden oder eine eigene bereitstellen. Dadurch lässt sich insbesondere einer bereits veröffentlichten Schnittstelle eine Methode hinzufügen, ohne dass alle Klassen, die sie implementieren, geändert werden müssen: So wurden die Collections im JDK über die aufeinanderfolgenden Versionen hinweg erweitert. Eine Schnittstelle kann außerdem statische Methoden (Java 8) und private Methoden (Java 9) enthalten. Das Programm [Classes17.java] liefert ein Beispiel:
- Zeilen 12–30: die Schnittstelle [IShape]:
- Zeile 14: eine abstrakte Methode [area], die implementiert werden muss;
- Zeilen 17–19: eine Methode [description] mit einer Standardimplementierung. Diese Methode kann die anderen Methoden der Schnittstelle ([area], [format]) und die von [Object] ([getClass]) verwenden;
- Zeilen 22–24: eine statische Methode, die über den Schnittstellennamen aufgerufen wird: [IShape.unitSquare()] (Zeile 3). Dies ist eine statische Fabrikmethode;
- Zeilen 27–29: eine private Methode, auf die nur die Methoden der Schnittstelle zugreifen können. [String.format("%.2f", value)] formatiert die Zahl mit zwei Nachkommastellen gemäß den Konventionen der Systemlocale – hier dem französischen Dezimalkomma;
- Zeilen 34–45: Die Klasse [Square] implementiert nur [area]; sie verwendet die Methode [description] in der Standardversion. Sie ist als [static] deklariert, weil die statische Methode [unitSquare] der Schnittstelle Quadrate erzeugt (siehe [Classes10.java]);
- Zeilen 48–64: Die Klasse [Circle] stellt eine eigene Methode [description] bereit. Das Format [%s] fügt den Radius ein, der von [Double.toString] in eine Zeichenkette umgewandelt wurde („1.0“), und das Format [%.2f] fügt die Fläche mit zwei Nachkommastellen ein;
- Zeile 9: Die Default-Methode wird von der Klasse [Square] wie jede andere Methode geerbt: Sie kann für eine Variable vom Typ [Square] aufgerufen werden.
Ergebnisse:
Eine Klasse kann zwei Schnittstellen implementieren, die jeweils eine Default-Methode mit derselben Signatur bereitstellen: Der Compiler verlangt dann, dass die Klasse die Methode neu definiert, notfalls indem sie eine der beiden Versionen über [I1.super.method()] aufruft. Anders als eine abstrakte Klasse hat eine Schnittstelle keinen Zustand: Sie kann keine Instanzfelder deklarieren, nur Konstanten ([static final], implizit).
4.7. Abstrakte Klassen
Eine abstrakte Klasse ist eine Klasse, die nicht instanziiert werden kann. Man muss abgeleitete Klassen erstellen, die instanziiert werden können. Mit abstrakten Klassen lässt sich der Code einer Klassenhierarchie refaktorieren. Betrachten wir das folgende Beispiel, das den Ordner [Users] [User.java] bildet:
- Zeile 1: Die Klasse wird mit dem Schlüsselwort [abstract] als abstrakt deklariert;
- Zeilen 9–20: der Konstruktor der Klasse [User]. Diese Klasse speichert Informationen über den Benutzer einer Webanwendung. Die Anwendung kennt verschiedene Arten von Benutzern, die durch Benutzername und Passwort authentifiziert werden (Zeilen 3–4). Diese beiden Angaben werden für manche Benutzer anhand eines Verzeichnisses (LDAP) überprüft, für andere anhand einer Datenbank und so weiter. Der Konstruktor ist [protected]: Er ist für die Konstruktoren abgeleiteter Klassen gedacht;
- Zeilen 11–12: Die Authentifizierungsdaten werden gespeichert;
- Zeile 14: Sie werden durch eine Methode [identify]. Da die Identifizierungsmethode auf dieser Ebene nicht bekannt ist, wird sie (Zeile 29) mit dem Schlüsselwort [abstract] als abstrakt deklariert. Eine abstrakte Methode hat keinen Rumpf: Abgeleitete Klassen stellen einen bereit. Eine Klasse mit einer abstrakten Methode muss selbst als abstrakt deklariert werden. Die Methode [identify] gibt eine Zeichenkette zurück, die die Rolle des Benutzers angibt (im Grunde, wozu er berechtigt ist), oder [null] , falls der Benutzer nicht erkannt wird;
- Zeilen 16–18: Wird der Benutzer nicht erkannt, wird eine Ausnahme ausgelöst. Die Ausnahme [UnknownUserException] ist eine geprüfte Ausnahme (siehe unten): Der Konstruktor muss sie mit der [throws UnknownUserException]-Klausel (Zeile 9) deklarieren;
- Zeilen 23–26: die Methode [toString], die eine Instanz der Klasse identifiziert.
Hier nehmen wir an, dass der Entwickler die Erzeugung von Instanzen der Klasse [User] und ihrer abgeleiteten Klassen kontrollieren möchte, etwa um sicherzustellen, dass eine Ausnahme eines bestimmten Typs ausgelöst wird, wenn der Benutzer nicht erkannt wird. Abgeleitete Klassen können sich auf diesen Konstruktor stützen. Dazu müssen sie die Methode [identify] bereitstellen. Beachten Sie, dass der Konstruktor hier eine von den abgeleiteten Klassen überschriebene Methode aufruft, obwohl diese Klassen ihre eigenen Konstruktoren noch nicht ausgeführt haben: Die Methode [identify] darf daher keine Felder der abgeleiteten Klasse verwenden, da diese noch nicht initialisiert sind. Diese Praxis sollte mit Vorsicht eingesetzt werden, und der Compiler weist beim Kompilieren mit der Option [-Xlint:all], die alle Warnungen aktiviert, darauf hin (hier ohne die Annotation in Zeile 8, daher die Zeilennummer 13 in der Meldung):
Die Warnung [this-escape] (Java 21) weist darauf hin, dass das im Aufbau befindliche Objekt ([this]) den Konstruktor „verlässt“, bevor es vollständig initialisiert ist. Hier ist das beabsichtigt und unbedenklich, da die Methoden [identify] der abgeleiteten Klassen keine Felder verwenden. Nach dieser Prüfung wird die Warnung – nur für diesen Konstruktor – mit der Annotation [@SuppressWarnings("this-escape")] (Zeile 8) unterdrückt. Der Quellcode-Launcher ([java Main.java]) aktiviert diese Warnungen nicht: Es ist empfehlenswert, Ihre Programme regelmäßig mit [javac -Xlint:all] zu kompilieren, wie wir es für alle Programme in diesem Kurs getan haben.
Die Klasse [UnknownUserException] lautet wie folgt:
- Zeile 1: Sie ist von der Klasse [Exception] abgeleitet. Es handelt sich daher um eine geprüfte Ausnahme (Checked Exception): Der Compiler überprüft, dass jede Methode, die sie auslösen kann, dies mit einer [throws]-Klausel deklariert und dass jeder Code, der eine solche Methode aufruft, sie entweder abfängt oder seinerseits deklariert. Eine von [RuntimeException] abgeleitete Ausnahme wie [IllegalArgumentException] ist keine geprüfte Ausnahme;
- Zeile 3: Ausnahmen sind „serialisierbare“ Objekte (in eine Bytefolge umwandelbar); der Compiler verlangt mit der Option [-Xlint:all], dass eine serialisierbare Klasse eine Versionsnummer [serialVersionUID] deklariert. Wir verwenden einfach den Wert 1;
- Zeilen 5–7: Sie hat nur einen einzigen Konstruktor, der eine Fehlermeldung als Parameter entgegennimmt. Diese wird an die Elternklasse weitergegeben, die denselben Konstruktor hat.
Wir leiten nun die Kindklasse [Administrator] von der Klasse [User] ab:
- Zeilen 3–5: Der Konstruktor gibt die erhaltenen Parameter einfach an seine Elternklasse weiter. Er deklariert außerdem die Ausnahme, die der Konstruktor der Elternklasse auslösen kann;
- Zeilen 8–13: die Methode [identify] der Klasse [Administrator]. Wir nehmen an, dass ein Administrator über ein LDAP-Verzeichnis identifiziert wird. Diese Methode implementiert die abstrakte Methode [identify] der Elternklasse. Sie behält die Zugriffsebene [protected] der überschriebenen Methode bei (eine überschriebene Methode darf den Zugriff erweitern, aber nicht einschränken).
Die Klassen [Observer] und [Unknown] sind ebenfalls von der Klasse [User] abgeleitet. Sie unterscheiden sich von der Klasse [Administrator] nur in ihrer Methode [identify]. Die Methode der Klasse [Observer] geht davon aus, dass ein Beobachter über eine Datenbank identifiziert wird, und gibt die Rolle „observer“ zurück:
Die Methode der Klasse [Unknown] gibt die Referenz [null] zurück, um anzuzeigen, dass der Benutzer nicht erkannt wurde:
Letztlich werden die Objekte [Administrator], [Observer], und [Unknown] vom selben Konstruktor initialisiert – dem der Elternklasse [User]. Dieser Konstruktor verwendet die von diesen Klassen bereitgestellte Methode [identify]. Ein Testprogramm für [Main.java] könnte so aussehen:
Beachten Sie, dass in den Zeilen 3 und 4 die Methode [User.toString()] von der Methode *[println] verwendet wird. In Zeile 5 löst der Konstruktor eine Ausnahme [UnknownUserException] aus, die in Zeile 6 abgefangen wird: Das Objekt wird nicht erzeugt, und es wird nichts durch [println] angezeigt. Die drei Objekterzeugungen stehen in einem [try]-Block, weil der Compiler verlangt, dass die geprüfte Ausnahme abgefangen wird. Zeile 9 wird, wenn man sie einkommentiert, vom Compiler abgelehnt ([User is abstract; cannot be instantiated]*): Von einer abstrakten Klasse kann kein Objekt erzeugt werden.
Ergebnisse:
Eine abstrakte Klasse ähnelt einer Schnittstelle: Beide deklarieren Methoden, die andere Klassen implementieren müssen. Eine abstrakte Klasse kann jedoch Felder, Konstruktoren und Code haben, der ihren abgeleiteten Klassen gemeinsam ist; umgekehrt kann eine Klasse nur von einer abstrakten Klasse erben, während sie mehrere Schnittstellen implementieren kann. Beide werden oft kombiniert: Eine Schnittstelle definiert den Vertrag, und eine abstrakte Klasse, die sie implementiert, fasst den mehreren Implementierungen gemeinsamen Code zusammen. Genau das wird die Beispielanwendung in diesem Kapitel tun.
4.8. Generische Klassen, Schnittstellen und Methoden
4.8.1. Generische Klassen und Methoden
Angenommen, wir möchten eine Klasse [IntPair] schreiben, die zwei ganze Zahlen speichert und vertauschen kann: zwei Felder, [int first] und [int second], und eine Methode [swap()], die ihre Werte mithilfe einer temporären Variablen [int temp] vertauscht. Wenn wir danach ein Paar von Zeichenketten und anschließend ein Paar von Personen bräuchten, würden wir zwei weitere Klassen schreiben, [StringPair] und [PersonPair], die der vorherigen bis auf den Typ identisch sind: [String] oder [Person] statt [int].
Generische Klassen, Schnittstellen und Methoden decken den Bedarf an Code, der sich nur im Typ bestimmter Daten unterscheidet. Sie wurden mit Java 5 (2004) eingeführt: Davor wurde der Typ [Object] verwendet, der alles akzeptierte, um den Preis expliziter Typumwandlungen und von Fehlern, die erst zur Laufzeit erkannt werden. Beachten Sie, dass Java die Parameterübergabe per Referenz nicht unterstützt: Eine Methode kann die Werte zweier Variablen des Aufrufers nicht vertauschen, wohl aber zwei Elemente eines Objekts, eines Paares oder eines Arrays.
Das Programm [Classes18.java] enthält eine generische Klasse, eine generische Methode und eine zweite generische Klasse:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 | |
- Zeilen 41–69: Die Klasse
[Pair]wird durch einen Typ parametrisiert, der mit*[T]bezeichnet und in spitzen Klammern nach dem Klassennamen angegeben wird. Sie können ihn beliebig benennen; üblicherweise ist es ein Großbuchstabe ([T] für Typ, [E] für Element, [K] und [V] für Schlüssel und Wert). Dieser Typ, [T], wird dann in der Klasse wie jeder andere Typ verwendet: für die beiden Felder, die Konstruktorparameter, die Ergebnisse der Accessoren und die temporäre Variable [temp]* (Zeile 60). Die Klasse [Pair] wird als generische Klasse bezeichnet; - Zeile 5: Bei der Verwendung einer generischen Klasse, die durch die Typen T1, T2, … parametrisiert ist, müssen diese Typen angegeben werden. Hier ist [Pair<Integer>] ein Paar von [Integer]-Objekten. Ein generischer Parameter kann nur ein Referenztyp sein: Wir schreiben [Pair<Integer>], nicht [Pair<int>]. Die ganzen Zahlen 1 und 2 werden automatisch in [Integer]-Objekte umgewandelt („Autoboxing“). Rechts ermöglicht der „Diamond“-Operator [new Pair<>(...)] dem Compiler, den Typ [Integer] aus dem der Variablen abzuleiten. Zeilen 9 und 14: Dasselbe gilt für die Typen [String] und [Person];
- Zeile 18: Die Methode [getFirst] eines [Pair<Person>] gibt ein Objekt vom Typ [Person], ohne Umwandlung zurück;
- Zeilen 72–79: Die Klasse [Generic2] ist nicht generisch, aber ihre statische Methode [swap] ist es: Der Parameter vom Typ [<T>] wird vor dem Rückgabetyp deklariert (Zeile 74). Die Methode vertauscht die Elemente i und j eines Arrays mit Elementen vom Typ [T];
- Zeile 23: Die Methode
[swap]wird aufgerufen, wobei der Typ*[T]zwischen***[<>]angegeben wird. Tatsächlich kann der Compiler [T] aus dem Typ der tatsächlichen Parameter ableiten. Daher ist die Schreibweise in Zeile 27 gültig, und sie ist die in der Praxis verwendete; - Zeilen 82–103: eine generische Klasse mit Zustand: ein Stapel von Elementen vom Typ [T]. Elemente werden oben auf den Stapel gelegt und von oben entnommen. Die Elemente werden in einer generischen Liste vom Typ [List<T>] (Zeile 84) gespeichert, die selbst durch den Typ [T] des Stapels parametrisiert ist. Die Methode [removeLast] (Java 21) ruft das letzte Element der Liste ab und gibt es zurück. Ein leerer Stapel löst eine Ausnahme [IllegalStateException] aus, die Ausnahme, die Java für eine von einem Objekt angeforderte Operation definiert, das sich nicht im erwarteten Zustand befindet;
- Zeile 31: ein Stapel von Personen. Der Compiler garantiert, dass er nur Personen enthält: Die Anweisung in Zeile 37 würde abgelehnt. Die Methode [pop] liefert ein Objekt vom Typ [Person], ohne Konvertierung;
- Zeilen 106–111: Die Person ist ein Record, für den die Methode [toString] neu definiert wurde.
Ergebnisse:
4.8.2. Schranken generischer Parameter
In der Klasse [Pair<T>] weiß der Compiler nichts über den Typ [T]: Er erlaubt nur, die Methoden der Klasse [Object] für Objekte vom Typ [T] aufzurufen. Um andere Methoden verwenden zu können, beschränken wir den generischen Parameter mit dem Schlüsselwort [extends]:
Einschränkung | Bedeutung |
[<T extends BaseClass>] | T muss die angegebene Klasse oder eine davon abgeleitete Klasse sein |
[<T extends Interface>] | T muss die angegebene Schnittstelle implementieren (geschrieben als [extends], nicht als [implements]) |
[<T extends BaseClass & I1 & I2>] | Mehrere Angaben: höchstens eine Klasse, die an erster Stelle steht, gefolgt von Schnittstellen |
[<T extends Comparable<T>>] | Eine Schranke, die T selbst verwendet: T muss mit T vergleichbar sein |
Es gibt keine Einschränkung, die verlangt, dass T ein Referenztyp ist (das ist es immer) oder einen parameterlosen Konstruktor besitzt: Sie können [new T()] in einer generischen Klasse nicht schreiben (siehe Type Erasure weiter unten). Das Programm [Classes19.java] verwendet eine Einschränkung:
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 | |
- Zeile 5: Wenn Sie diese Zeile auskommentieren, meldet der Compiler einen Fehler, weil der Typ
*[int]* ein primitiver Typ ist; - Zeilen 55–62: Die generische Methode [order] verlangt, dass der Typ [T] die Schnittstelle [IValue] implementiert (Zeilen 65–67). Diese Schnittstelle besitzt eine Methode namens [value], die in Zeile 58 verwendet wird und den Wert des Objekts vom Typ [T] zurückgibt. Ohne die Schranke würde der Compiler den Aufruf von [pair.getFirst().value()] ablehnen: Nicht jeder [T]-Typ hat eine Methode [value]. Die beiden Elemente des Paares werden nur vertauscht, wenn der Wert des ersten größer ist als der des zweiten: Die Methode [order] sortiert die beiden Elemente aufsteigend nach ihrem Wert;
- Zeilen 70–86: Die Klasse [RandomValue] implementiert die Schnittstelle [IValue]. Der Wert einer Instanz ist eine Zufallszahl zwischen 0 und 99 (Zeile 75), die von einem Zufallszahlengenerator der Klasse [Random] geliefert wird, der von allen Instanzen gemeinsam genutzt wird (Zeile 73). Dieser Generator wird mit einem festen „Seed“ initialisiert: Er erzeugt daher immer dieselbe Zahlenfolge, sodass die Ergebnisse reproduzierbar sind. Wenn keine Reproduzierbarkeit erforderlich ist, wird der von [new Random()] erzeugte Generator verwendet; für sicherheitsrelevante Zwecke verwendet man stattdessen die Klasse [SecureRandom];
- Zeilen 89–105: Die Klasse [StringValue] implementiert ebenfalls die Schnittstelle [IValue]: Der Wert einer Instanz ist die Länge der Zeichenkette, die dem Konstruktor übergeben wird;
- Zeilen 10–15: Paare von Objekten des Typs [RandomValue] werden geordnet;
- Zeilen 17–20: Ein Paar von Objekten des Typs [StringValue] wird geordnet;
- Zeile 21: Wenn Sie diese Zeile auskommentieren, meldet der Compiler, dass der Typ [Integer] die Schranke nicht erfüllt.
Ergebnisse:
Hier sind die Fehler, die bei der Ausführung des Programms entstehen, nachdem die Zeilen 5 und 21 auskommentiert wurden:
Die zweite Meldung ist typisch für Fehler im Zusammenhang mit Generics: Der Compiler hat versucht, den Typ [T] abzuleiten; die Einschränkung des Paares verlangt [T] = [Integer] („Gleichheitsbedingungen“), die Schranke verlangt, dass [T] die Schnittstelle [IValue] implementiert („obere Schranken“); die beiden Bedingungen sind unvereinbar.
4.8.3. Generische Schnittstellen: Comparable<T> und Comparator<T>
Um das Konzept einer generischen Schnittstelle zu veranschaulichen, sortieren wir ein Array von Personen nach verschiedenen Kriterien. Zum Sortieren eines Arrays dient die statische Methode [sort] der Klasse [java.util.Arrays]. Sie ist überladen; wir verwenden zwei Varianten:
- [Arrays.sort(Object[] array)] sortiert das Array nach der natürlichen Ordnung seiner Elemente: Diese Elemente müssen die Schnittstelle [Comparable<T>] implementieren, deren einzige Methode [int compareTo(T other)], das aktuelle Objekt mit dem Objekt [other] vergleicht;
- [Arrays.sort(T[] array, Comparator<? super T> comparator)] sortiert das Array nach der Ordnung, die von einem Comparator-Objekt definiert wird, das die Schnittstelle [Comparator<T>] implementiert und dessen Methode [int compare(T x, T y)] zwei Objekte vergleicht (der Typ [? super T] wird im folgenden Absatz erläutert).
Die Methoden [compareTo] und [compare] folgen derselben Regel: Sie geben eine positive Zahl zurück, wenn x > y ist, 0, wenn x == y ist, und eine negative Zahl, wenn x < y ist. Es liegt in der Verantwortung des Entwicklers, die Bedeutung der Operatoren <, == und > festzulegen. Wenn zum Beispiel [p1] und [p2] zwei [Person]-Objekte sind, können wir festlegen, dass p1 > p2 gilt, wenn der Name von [p1] alphabetisch nach dem Namen von [p2] kommt. Das ergibt eine aufsteigende Sortierung nach den Namen der Personen. Wenn wir nach Alter sortieren wollen, legen wir fest, dass p1 > p2 gilt, wenn das Alter von [p1] größer ist als das Alter von [p2]. Um absteigend zu sortieren, genügt es, die Vorzeichen der Ergebnisse umzukehren.
Wir wissen nun genug, um ein Array von Personen zu sortieren. Das Programm [Classes20.java] lautet wie folgt:
- Zeilen 3–7: das Array der Personen;
- Zeilen 35–68: Die Klasse [Person] implementiert die generische Schnittstelle [Comparable<Person>]: Ihre Objekte sind mit anderen Personen vergleichbar. Ihre Methode [compareTo] (Zeilen 59–62) definiert die natürliche Ordnung der Personen, hier nach dem Alter. Die statische Methode [Integer.compare(a, b)] liefert eine negative Zahl, null oder eine positive Zahl, je nachdem, ob [a] kleiner, gleich oder größer als [b] ist: Genau das erwartet die Methode [compareTo];
- Zeile 11: Sortierung in natürlicher Ordnung;
- Zeile 14: Sortiert das Array der Personen nach Nachname und Vorname. Der zweite Parameter der Methode [sort] ist eine Instanz der Klasse [CompareNames], die die generische Schnittstelle [Comparator<Person>] implementiert;
- Zeilen 71–85: die Klasse [CompareNames]. Ihre Methode [compare] implementiert die Methode [int compare(T x, T y)] der Schnittstelle [Comparator<T>], wobei [T] = [Person] gilt. Zeichenketten werden nicht mit ihrer Methode [compareTo] verglichen, die der Reihenfolge der Zeichencodes folgt (Großbuchstaben vor Kleinbuchstaben, Buchstaben mit Akzent nach „z“), sondern mit einem [Collator]-Objekt (Zeile 73), das die Sortierregeln der französischen Sprache anwendet;
- Zeilen 17–22: Sortierung nach Alter in absteigender Reihenfolge. Der Comparator ist diesmal eine Instanz einer anonymen Klasse: Der Ausdruck [new Comparator<Person>() { ... }] deklariert eine namenlose Klasse, die die Schnittstelle [Comparator<Person>] implementiert, und erzeugt sofort eine Instanz dieser Klasse. Der Rumpf der Klasse (Zeilen 18–21) stellt die Methode [compare] bereit. Eine anonyme Klasse erspart es, eine Klasse zu deklarieren, die nur einmal verwendet wird;
- Zeile 28: Die Methode [repeat] (Java 11) füllt eine Zeichenkette auf: Die Titelzeile wird mit Bindestrichen auf 50 Zeichen aufgefüllt.
Ergebnisse:
Wir sind nun drei Arten von Klassen begegnet, die innerhalb einer anderen Klasse deklariert werden: statische verschachtelte Klassen ([static class]), innere Klassen (ohne [static]), die einem Objekt der umschließenden Klasse zugeordnet sind, und anonyme Klassen. In Kapitel 7 werden wir sehen, dass wir für eine Schnittstelle mit nur einer abstrakten Methode, wie etwa [Comparator], eine noch kürzere Alternative zur anonymen Klasse verwenden können: einen Lambda-Ausdruck, [Arrays.sort(persons, (p1, p2) -> Integer.compare(p2.getAge(), p1.getAge()));], oder eine Methodenreferenz, [Arrays.sort(persons, Comparator.comparing(Person::getLastName));].
4.8.4. Wildcards und Type Erasure
Eine [List<Integer>] ist keine [List<Number>], obwohl [Integer] von [Number] abgeleitet ist: Wäre sie es, könnten wir über eine Variable vom Typ [List<Number>] ein [Double] zu einer Liste von Ganzzahlen hinzufügen. Eine Methode, die eine [List<Number>] akzeptiert, lehnt daher eine [List<Integer>] ab. Um Methoden zu schreiben, die Listen mit Elementen verwandter Typen akzeptieren, verwendet Java Wildcards:
Typ | Bedeutung | Verwendung |
[List<? extends Number>] | eine Liste mit Elementen eines unbekannten Typs, der von [Number] abgeleitet ist | Sie können daraus [Number] lesen, aber keine Elemente hinzufügen |
[List<? super Integer>] | Eine Liste mit Elementen eines unbekannten Typs, von dem [Integer] abgeleitet ist ([Integer], [Number], [Object]) | [Integer] kann dieser Liste hinzugefügt werden |
[List<?>] | eine Liste mit Elementen eines unbekannten Typs | Sie können [Object] lesen |
Das Programm [Classes21.java] veranschaulicht Wildcards und eine Besonderheit der generischen Typen in Java: die Type Erasure:
- Zeilen 22–29: Die Methode [sum] akzeptiert eine Liste mit Elementen beliebigen Typs, der von [Number] abgeleitet ist: [Integer], [Double], [BigDecimal] … Sie behandelt die Elemente als [Number] und verwendet deren Methode [doubleValue]. Java unterstützt keine generische Arithmetik: Sie können für zwei Objekte vom Typ [a + b] nicht [T] schreiben, daher ist die Verwendung von [double] nötig. Das Hinzufügen eines Elements zur Liste (Zeile 27) wird abgelehnt: Der Compiler weiß nicht, ob es sich um eine Liste von [Integer] oder von [Double] handelt;
- Zeilen 6–7: Dieselbe Methode summiert eine Liste von [Integer] und eine Liste von [Double]. [List.of(...)] erzeugt eine schreibgeschützte Liste;
- Zeilen 32–36: Die Methode [addIntegers] akzeptiert jede Liste, die [Integer]-Einträge aufnehmen kann, hier eine [List<Number>] (Zeile 10). Wir befolgen die Regel „Producer: [extends], Consumer: [super]“: Eine Liste, deren Elemente gelesen werden, wird mit [extends] geschrieben, und eine Liste, die gefüllt wird, mit [super];
- Zeilen 39–47: Die generische Methode
*[max]gibt das größte Element einer Liste zurück. Die Schranke [T extends Comparable<? super T>] verlangt, dass die Elemente untereinander vergleichbar sind; sie gilt sowohl für Zeichenketten als auch für Ganzzahlen (Zeile 14). Die Methode [getFirst]* (Java 21) gibt das erste Element der Liste zurück; - Zeilen 16–18: Zur Laufzeit sind eine
***[List<String>]und eine***[List<Integer>]zwei Objekte derselben Klasse,*[ArrayList]*. Der Compiler prüft die generischen Typen und löscht sie dann: Der kompilierte Code kennt nur noch [ArrayList] und [Object], und wo nötig werden Konvertierungen eingefügt. Diese „Type Erasure“, die 2004 eingeführt wurde, damit generischer Code mit bestehendem Code kompatibel bleibt, erklärt mehrere Einschränkungen: Sie können weder [new T()] noch [new T[10]] schreiben, ebenso wenig können Sie [o instanceof List<String>] testen, und ein primitiver Typ kann nicht als generischer Parameter verwendet werden.
Ergebnisse:
Anders als in anderen Sprachen wie C#, wo Schnittstellen abstrakte statische Member deklarieren können, um generische Berechnungen umzusetzen, erlaubt Java nicht, von einem Typ wie [T] eine statische Methode zu verlangen: Statische Methoden einer Schnittstelle werden über den Namen der Schnittstelle aufgerufen und von den Klassen, die sie implementieren, nicht geerbt.
4.9. Pakete
Um eine Zeile auf dem Bildschirm auszugeben, verwenden wir die Anweisung [IO.println(...)]. Wenn wir die Definition der Klasse [IO] in der JDK-Dokumentation nachschlagen, stellen wir fest, dass sie zu dem [java.lang]-Paket gehört. Das bedeutet, dass ihr vollständiger Name [java.lang.IO] lautet und dass wir [java.lang.IO.println(...)] schreiben könnten. Die Klassen des Pakets [java.lang] ([String], [Object], [Math], [Integer] …) werden immer mit ihrem einfachen Namen angesprochen. Für die übrigen verwendet man eine [import]-Klausel, die am Anfang der Datei steht:
- [import java.util.List;] importiert die Klasse [List] aus dem Paket [java.util];
- [import java.util.*;] importiert bei Bedarf alle öffentlichen Klassen des Pakets [java.util];
- [import module java.base;] (Java 25) importiert alle öffentlichen Klassen der Pakete, die vom Modul [java.base] exportiert werden (siehe unten). Das geschieht implizit in einer kompakten Datei;
- [import static java.lang.Math.sqrt;] importiert ein statisches Member einer Klasse, das dann ohne Angabe des Klassennamens verwendet werden kann: [sqrt(2)].
Wenn der Compiler auf den Kurznamen einer Klasse stößt, sucht er sie im aktuellen Paket und unter den importierten Klassen. Eine [import]-Klausel fügt dem Programm nichts hinzu: Sie erspart lediglich das Ausschreiben der vollständigen Namen.
Wenn Sie eine Klasse erstellen, legen Sie sie in einem Paket ab. Pakete dienen dazu, Namenskonflikte zwischen Klassen zu vermeiden, zum Beispiel wenn diese weitergegeben werden. Angenommen, zwei Firmen, E1 und E2, vertreiben Klassen, die in den Archiven [e1.jar] bzw. [e2.jar] verpackt sind. Ein Kunde C erwirbt beide Klassensammlungen, in denen beide Firmen eine Klasse namens [Person] definiert haben. Wenn die Firma E1 ihre Klassen in einem Paket namens [e1] und die Firma E2 ihre Klassen in einem Paket namens [e2] erstellt, heißen die beiden Klassen [Person] dann [e1.Person] und [e2.Person]. Der Kunde kann eine von beiden importieren und die andere mit ihrem vollständigen Namen ansprechen. Das Paket löst diese Mehrdeutigkeit auf. Üblicherweise werden Paketnamen kleingeschrieben und beginnen mit dem umgekehrten Domänennamen der Organisation, die sie veröffentlicht ([com.mysql.cj.jdbc], [org.hibernate] …); für unsere Beispiele verwenden wir kurze Namen.
Um eine Klasse in einem Paket abzulegen, schreiben Sie die Deklaration [package name;] an den Anfang ihrer Datei. Anders als in anderen Sprachen verlangt Java eine Eins-zu-eins-Entsprechung zwischen Paketen und Verzeichnissen: Die Quelldateien des Pakets [e1] liegen in einem Ordner namens [e1], die des Pakets [tax.dao] in einem Ordner namens [tax/dao], ausgehend von der Wurzel des Quellverzeichnisses. Der Ordner [Namespaces] veranschaulicht diese Konzepte:
Die erste Klasse, [Person] [e1/Person.java]:
Die zweite: [e2/Person.java]:
Beide Klassen sind öffentlich: Eine Klasse ohne das Schlüsselwort [public] ist nur für Klassen ihres eigenen Pakets zugänglich. Das Hauptprogramm [Main.java] lautet wie folgt:
- Zeile 2: Import der Klasse [e1.Person];
- Zeile 4: statischer Import der Methode [sqrt] aus der Klasse [Math];
- Zeile 8: [Person] bezeichnet die Klasse [e1.Person], die importiert wurde;
- Zeile 10: Der vollständige Name der Klasse [e2.Person] beseitigt jede Mehrdeutigkeit. Java unterstützt keine Typaliase: Sie können einer Klasse keinen anderen Namen geben;
- Zeilen 13–14: Die Methode [getName] der Klassenbeschreibung gibt ihren vollständigen Namen zurück, dem das Paket vorangestellt ist; [getPackageName] gibt den Paketnamen zurück;
- Zeilen 16–17: Die Methode [getModule] gibt das Modul zurück, das die Klasse enthält (siehe unten);
- Zeilen 19–20: Die Klasse [java.lang.StringBuilder] wird ohne Import erkannt;
- Zeile 22: Verwendung des statischen Imports.
Der Source-Code-Launcher findet Klassen in Unterordnern automatisch: Der Befehl [java Main.java], im Ordner [Namespaces] eingegeben, kompiliert die Dateien [e1/Person.java] und [e2/Person.java] bei Bedarf. Ergebnisse:
Wenn wir den Import in Zeile 2 durch die beiden Bedarfsimporte [import e1.*;] und [import e2.*;] ersetzen, wird der Name [Person] mehrdeutig, und der Compiler lehnt ihn ab:
4.9.1. Module
Seit Java 9 werden Pakete ihrerseits in Modulen („Java Platform Module System“, JPMS) zusammengefasst. Das JDK ist in Module unterteilt: [java.base] enthält die grundlegenden Pakete ([java.lang], [java.util], [java.math], [java.io] …), [java.sql] stellt den Datenbankzugriff bereit, [java.net.http] ist der HTTP-Client usw. Ein Modul deklariert in einer Datei namens [module-info.java] im Stammverzeichnis seines Quellcodes seinen Namen, die Module, die es benötigt ([requires java.sql;]), und die Pakete, die es anderen Modulen zur Verfügung stellt ([exports tax.business;]): Ein nicht exportiertes Paket ist von außen unsichtbar, selbst für seine öffentlichen Klassen. Die Klassen einer Anwendung, die kein Modul deklariert – wie unsere –, gehören zu dem unbenannten Modul (Zeile 5 der Ergebnisse), das Zugriff auf alle Module hat. Das ist bei den meisten Anwendungen der Fall und bei allen in diesem Kurs: Module sind vor allem für Autoren von Bibliotheken und für das JDK selbst interessant.
4.10. Records
Viele Klassen dienen nur dazu, Daten zu transportieren: eine Person, eine Note, eine Steuerstufe … Für sie schreiben wir immer denselben Code: private und [final]-Felder, einen Konstruktor, der seine Parameter in die Felder kopiert, Zugriffsmethoden, eine Methode [toString] , die die Felder anzeigt, sowie die Methoden [equals] und [hashCode]. Java 16 hat Records eingeführt: Der Compiler erzeugt diesen Code aus einer einzeiligen Deklaration. Wir sind ihnen im Abschnitt über unveränderliche Objekte begegnet; das Programm [Classes22.java] zeigt sie ausführlicher:
- Zeilen 48–59: der Record [Person]. Die Deklaration [record Person(String firstName, String lastName, int age)] erzeugt:
- drei private Felder – [final], [firstName], [lastName]und [age] –, die die Komponenten des Records sind;
- einen Konstruktor mit drei Parametern, den sogenannten kanonischen Konstruktor;
- drei öffentliche Zugriffsmethoden: [firstName()], [lastName()] und [age()] (Zeile 8);
- eine Methode [toString] , die den Typnamen und seine Komponenten anzeigt (Zeile 6);
- die Methoden [equals] und [hashCode], die die Werte der Komponenten statt der Referenzen vergleichen;
- Zeilen 51–53 und 56–58: Ein Record kann wie eine Klasse zusätzliche Methoden besitzen und Schnittstellen implementieren (Zeile 48);
- Zeile 10: [r1] und [r2] sind zwei verschiedene Objekte ([==] ergibt [false]), aber sie sind bezüglich [equals] gleich, weil ihre Komponenten dieselben Werte haben. Bei einer gewöhnlichen Klasse vergleicht [equals] Referenzen (Zeile 26);
- Zeile 14: Da ein Record unveränderlich ist, kann er nicht geändert werden (Zeile 12): Die „Wither“-Methode [withAge] erzeugt eine Kopie von [r1] mit geändertem Alter;
- Zeilen 18–20: ein Record-Pattern (Java 21): Wenn [r1] eine [Person] ist, werden ihre Komponenten in die Variablen [firstName], [lastName], und [age] extrahiert. Man spricht von einer Dekomposition des Records. Diesen Patterns werden wir beim Pattern Matching wieder begegnen;
- Zeilen 62–67: Ein Record ist implizit final und leitet implizit von der Klasse [java.lang.Record] ab; er kann weder von einer anderen Klasse oder einem anderen Record abgeleitet werden noch selbst Basis einer Ableitung sein. Um den Records [Person] und [Teacher] einen gemeinsamen Typ zu geben, lassen wir sie dieselbe Schnittstelle implementieren, hier [HasIdentity] (Zeilen 43–45). Der Record [Teacher] enthält daher die Komponenten der Person;
- Zeile 34: Die Gleichheit von Records berücksichtigt den tatsächlichen Typ der Objekte: Eine [Person] ist niemals gleich einem [Teacher], selbst wenn ihre gemeinsamen Komponenten gleich sind;
- Zeilen 36–39: Die gemeinsame Schnittstelle erlaubt es, beide Records polymorph zu behandeln;
- Zeilen 70–92: eine Klasse, die dem Record [Person] ähnelt … nur dass die Felder, der Konstruktor und die Zugriffsmethoden geschrieben werden mussten und weder die Gleichheit nach Werten noch [toString] bereitgestellt werden.
Ergebnisse:
Beachten Sie, dass die Methode [toString] der Klasse [PersonC] dieselbe ist wie die der Klasse [Object] (Zeile 8 der Ergebnisse) und dass die Gleichheit der beiden Objekte [PersonC] falsch ist (Zeile 9).
Fassen wir die Unterschiede zwischen einer Klasse und einem Record zusammen:
Klasse | Record | |
Gleichheit mit [equals] | dasselbe Objekt (sofern nicht neu definiert) | gleiche Komponentenwerte, gleicher Typ |
[toString] | Klassenname und Hashcode | Name des Records und Komponenten |
Felder, Konstruktor, Zugriffsmethoden | selbst zu schreiben | durch die Deklaration erzeugt |
Zustand | veränderlich oder nicht | unveränderlich (Felder [final]), keine weiteren Instanzfelder |
veränderte Kopie | selbst zu schreiben | selbst zu schreiben (mithilfe von „Wither“-Methoden) |
Vererbung | von einer Klasse, von mehreren Schnittstellen | von keiner Klasse, von mehreren Schnittstellen; ein Record ist immer final |
Ein Record dient für Daten, die durch ihren Wert definiert sind (eine aus einer Datenbank abgerufene Person, eine über ein Netzwerk ausgetauschte Nachricht, eine Steuerstufe), eine Klasse für ein Objekt mit Identität und Verhalten (ein Berechnungsservice, eine Verbindung, eine veränderliche Liste). Hinweis: Ein Record ist nur „oberflächlich“ unveränderlich: Wenn eine Komponente auf ein veränderliches Objekt – etwa eine Liste – verweist, bleibt der Inhalt dieser Liste veränderlich. In solchen Fällen verwendet man unveränderliche Listen ([List.copyOf]).
4.11. Konstruktoren von Records
Der kanonische Konstruktor eines Records kopiert lediglich seine Parameter in die Felder. Möglicherweise möchten Sie diese Parameter jedoch prüfen oder normalisieren. Java stellt dafür den kompakten Konstruktor bereit sowie die Möglichkeit, weitere Konstruktoren hinzuzufügen. Das Programm [Classes23.java] veranschaulicht dies:
- Zeilen 30–36: der kompakte Konstruktor. Er wird ohne Parameterliste geschrieben; seine Parameter sind implizit die des kanonischen Konstruktors ([firstName], [lastName], [age]). Sein Code wird zuerst ausgeführt; anschließend werden die Felder automatisch mit den – möglicherweise geänderten – Werten der Parameter initialisiert. Hier werden Vorname und Nachname geprüft und von führenden und nachgestellten Leerzeichen befreit (Zeilen 31–32), und ein negatives Alter wird abgelehnt (Zeilen 33–35). In einem kompakten Konstruktor können Sie den Feldern keine Werte zuweisen ([this.firstName = ...] wird abgelehnt): Sie ändern die Parameter;
- Zeilen 39–41: Ein Record kann weitere Konstruktoren haben, diese müssen jedoch den kanonischen Konstruktor mit [this(...)] aufrufen: Jede Erzeugung einer [Person] durchläuft somit die Prüfungen des kompakten Konstruktors;
- Zeilen 44–46: Ein Record ist unveränderlich; ihn altern zu lassen bedeutet, eine neue Instanz zu erzeugen;
- Zeilen 53–58: eine statische private Prüfmethode;
- Zeilen 61–72: Ein Record kann statische Felder (Zeile 63) und statische Methoden (Zeilen 65–67) besitzen, etwa die statische Fabrikmethode [origin], aber keine Instanzfelder zusätzlich zu seinen Komponenten.
Ergebnisse:
Der Vorname, der von Leerzeichen umgeben übergeben wurde (Zeile 3), wurde ohne sie gespeichert (Zeile 2 der Ergebnisse). Der kompakte Konstruktor ist der idiomatische Weg, um sicherzustellen, dass ein Record stets gültig ist: Es gibt keine Möglichkeit, eine [Person] zu erzeugen, ohne ihn zu durchlaufen.
4.12. Keine Erweiterungsmethoden: statische Hilfsmethoden
Wie fügt man einer Klasse, die nicht geändert werden kann, eine Methode hinzu, etwa der Klasse [String] aus dem JDK? Einige Sprachen, etwa C# oder Kotlin, bieten „Erweiterungsmethoden“: statische Methoden, die wie Instanzmethoden des erweiterten Typs verwendet werden. Java kennt sie nicht. Stattdessen schreiben wir statische Methoden, die in einer Hilfsklasse zusammengefasst sind, und rufen sie über den Namen ihrer Klasse auf, wobei wir das Objekt als Parameter übergeben. Das JDK ist voll davon: [Arrays], [Collections], [Objects], [Math] … Das Programm [Classes24.java] veranschaulicht dies:
- Zeilen 25–48: die Hilfsklasse [Tools]. Sie ist final, und ihr einziger Konstruktor ist privat (Zeilen 26–27): Sie kann weder abgeleitet noch instanziiert werden. Alle ihre Methoden sind statisch;
- Zeilen 29–31: Die Methode [initials] erhält die Person als Parameter. Wie eine in einer anderen Datei geschriebene Hilfsklasse verwendet sie nur die öffentlichen Member des Records [Person] – hier seine Zugriffsmethoden (in einer kompakten Datei hätte sie jedoch Zugriff auf private Felder); [charAt(0)] gibt das erste Zeichen einer Zeichenkette zurück;
- Zeile 2: Der statische Import der Methode [Character.toUpperCase], die ein Zeichen in einen Großbuchstaben umwandelt, erlaubt ihren Aufruf ohne Klassennamen (Zeilen 30 und 34);
- Zeilen 45–47: Die Methode [nbWords] zerlegt die Zeichenkette mit der Methode [split], deren Parameter ein regulärer Ausdruck ist: ["\\s+"] steht für eine Folge von einem oder mehreren Leerraumzeichen;
- Zeilen 7–10: Hilfsmethoden werden über den Klassennamen aufgerufen: [Tools.initials(p)], nicht [p.initials()];
- Zeilen 19–21: Wenn der Typ geändert werden kann, gehören seine Methoden natürlich dorthin: Die statische Fabrikmethode [unknown] ist eine Methode des Records [Person] (Zeile 12).
Ergebnisse:
Mit einem statischen Import ([import static tools.Tools.*;] , wenn die Klasse in einem Paket namens [tools] läge) könnte man [initials(p)] ohne den Klassennamen schreiben. Damit eine Hilfsmethode verwendbar ist, muss ihre Klasse zugänglich und, wenn sie in einem anderen Paket liegt, importiert sein.
4.13. Pattern Matching bei Objekten
Die [switch]-Anweisung und das Pattern Matching sind nicht auf einfache Werte (Zahlen, Zeichenketten) beschränkt; sie lassen sich auch auf Objekte anwenden. Sie können den Typ eines Objekts testen, einen Record zerlegen, eine Bedingung hinzufügen und das Objekt in den richtigen Typ konvertiert erhalten – alles in einem einzigen Ausdruck. Das Programm [Classes25.java] verwendet eine versiegelte Schnittstelle und drei Records, die sie implementieren:
- Zeilen 66–79: eine versiegelte Schnittstelle [Person], die von drei Records implementiert wird: [Individual], [Teacher] und [Student]. Die Schnittstelle deklariert die Methoden [firstName], [lastName] und [age]: Die Records implementieren sie automatisch über ihre Zugriffsmethoden, da sie Komponenten mit denselben Namen besitzen. Da ein Record final ist, kann er eine versiegelte Schnittstelle ohne weitere Angabe implementieren;
- Zeilen 3–12: ein Array von Objekten verschiedener Typen, darunter eine Ganzzahl (automatisch in
*[Integer]konvertiert) und die Referenz*[null]; - Zeile 16: das Typ-Pattern [o instanceof Person p] (Java 16) ist wahr, wenn [o] auf ein Objekt vom Typ [Person] verweist; in diesem Fall verweist die Variable [p] vom Typ [Person] auf dieses Objekt. Das vermeidet die vor Java 16 übliche Abfolge: den Typ mit [instanceof] testen und dann mit [(Person) o] konvertieren. Das Pattern ist falsch, wenn [o] gleich [null] ist;
- Zeile 24: Die Pattern-Variable [p] kann im Rest der Bedingung nach [&&] verwendet werden: Java kennt keine Property-Patterns; Feldwerte werden mit einer Bedingung getestet;
- Zeilen 42–54: Der [switch]-Ausdruck auf einem Objekt (Java 21) probiert die Patterns der Reihe nach aus und liefert den Wert, der dem ersten passenden zugeordnet ist:
- Zeile 44: ein Lehrer aus Abschnitt 27. Die Klausel [when] fügt dem Typ-Pattern eine Bedingung hinzu, die als Guard bezeichnet wird;
- Zeile 45: jeder andere Lehrer. Die Reihenfolge ist wichtig: Stünde dieses Pattern vor dem vorherigen, würde es dieses unerreichbar machen, was der Compiler als Fehler melden würde;
- Zeile 46: ein Record-Pattern: Es extrahiert die Komponenten des Records [Student] in der Reihenfolge ihrer Deklaration; [var] lässt den Compiler ihren Typ ableiten, und das Zeichen [_] (Java 22) ignoriert eine Komponente;
- Zeilen 47–48: ein Minderjähriger, gefolgt von jeder anderen Person;
- Zeile 50: eine positive Ganzzahl;
- Zeile 51: der Fall [null]. Ohne ihn löst ein [switch] auf einer Null-Referenz eine [NullPointerException] aus;
- Zeile 52: Der Fall [default] behandelt alles Übrige. Ohne ihn würde der Compiler melden, dass der Ausdruck [switch] nicht alle Fälle abdeckt: Ein [switch] auf einem Objekt muss erschöpfend sein;
- Zeilen 57–63: ein [switch] auf einer [Person], ohne [default]. Er ist dennoch erschöpfend: Da die Schnittstelle versiegelt ist, weiß der Compiler, dass eine Person entweder ein [Individual], ein [Teacher] oder ein [Student] ist. Das Pattern [Individual _] testet den Typ, ohne eine Variable zu deklarieren.
Ergebnisse:
Wenn der Fall [Student] aus der Methode [category] entfernt wird, meldet der Compiler einen Fehler:
Das ist der große Vorteil der Kombination versiegelter Typen mit Pattern Matching: Wird der Hierarchie ein vierter Record hinzugefügt, findet der Compiler alle [switch]-Stellen, die ergänzt werden müssen. Beachten Sie außerdem, dass das Typ-Pattern den Typen entspricht, die die Schnittstelle implementieren: Die Schleife mit dem Typ-Pattern (Zeilen 15–20) hat die drei Personentypen ausgewählt. Pattern Matching ist eine nützliche Alternative zu verschachtelten [if (o instanceof ...)]-Anweisungen; es sollte jedoch den Polymorphismus nicht ersetzen: Hängt das Verhalten vom Typ des Objekts ab und ist die Klassenhierarchie klar definiert, bleibt eine in jeder Klasse überschriebene Methode oft die objektorientierte Lösung. Pattern Matching eignet sich gut für Datenhierarchien (Records), auf denen man eine von diesen Daten getrennte Verarbeitungslogik schreiben möchte.
4.14. Umgang mit dem Wert null
Jede Variable eines Referenztyps kann den Wert [null] haben, und die Verwendung einer Null-Referenz löst die Ausnahme [NullPointerException] aus, den häufigsten Laufzeitfehler in Java. Anders als andere Sprachen wie C# oder Kotlin unterscheidet der Java-Compiler nicht zwischen Typen, die [null] sein können, und solchen, die es nicht können. Das JDK und Bibliotheken stellen jedoch mehrere Werkzeuge bereit, um dieses Risiko zu verringern:
- die Klasse [Optional<T>] (Java 8), der Rückgabetyp einer Methode, die möglicherweise nichts zurückgibt;
- die Methoden der Klasse [Objects]: [requireNonNull] , um [null] am Eingang einer Methode oder eines Konstruktors abzulehnen, und [requireNonNullElse] , um einen Standardwert bereitzustellen;
- Annotationen, die die Absicht dokumentieren und von bestimmten Analysewerkzeugen geprüft werden. Die neuesten, von einer Gruppe von Anbietern (Google, JetBrains, Spring …) vorgeschlagenen sind die der Bibliothek JSpecify: [@Nullable] an einem Typ, der [null] sein kann, und [@NullMarked] an einer Klasse oder einem Paket, um anzuzeigen, dass andere Typen es nicht sein können. Spring Framework 7, das wir verwenden werden, setzt sie ein. Sie erfordern eine Bibliothek, daher verwenden wir sie in diesem Kapitel nicht.
Das Programm [Classes26.java] demonstriert die ersten beiden:
- Zeilen 56–83: Die Klasse [Person] hat zwei Pflichtfelder, die vom Konstruktor initialisiert werden, und ein optionales Feld, [middleName]: [null] bedeutet „kein zweiter Vorname“. Der Konstruktor lehnt einen Vor- oder Nachnamen mit dem Wert [null] mithilfe von [Objects.requireNonNull] ab (Zeilen 64–65): Der Fehler wird bei der Erzeugung des Objekts erkannt und nicht erst viel später, wenn das Feld verwendet wird;
- Zeile 8: [Objects.requireNonNullElse(value, defaultValue)] (Java 9) gibt [value] zurück, wenn es nicht gleich [null] ist; andernfalls gibt es [defaultValue] zurück;
- Zeile 10: Eine explizite Prüfung ist oft der einfachste Ansatz;
- Zeilen 47–54: Die Methode [find] gibt die gesuchte Person eingepackt in ein [Optional]-Objekt zurück, oder ein leeres [Optional]: Ihr Rückgabetyp [Optional<Person>] warnt den Aufrufer, dass das Ergebnis fehlen kann, und verpflichtet ihn, diesen Fall zu behandeln, um die Person abzurufen. [Optional.of(p)] erzeugt ein [Optional] mit [p], [Optional.empty()], ein leeres [Optional];
- Zeile 16: [isPresent] gibt an, ob [Optional] einen Wert enthält;
- Zeile 17: [map(Person::getFirstName)] wandelt eine vorhandene Person in ihren Vornamen um; [orElse(value)] gibt den vorhandenen Wert zurück oder, falls keiner vorhanden ist, den angegebenen Wert. Die Schreibweise [Person::getFirstName] ist eine Methodenreferenz, die wir in Kapitel 7 untersuchen werden; hier steht sie für „die Methode [getFirstName] der Person“;
- Zeilen 20–22: [get] gibt den vorhandenen Wert zurück; es wird erst nach der Prüfung seines Vorhandenseins aufgerufen;
- Zeilen 24–25: [ifPresent] führt die angegebene Aktion nur aus, wenn ein Wert vorhanden ist. Die Aktion ist ein Lambda-Ausdruck (Kapitel 7): [p -> p.setMiddleName("Louise")] liest sich als „für die Person p setze ihren zweiten Vornamen“. Dupont existiert und erhält einen neuen zweiten Vornamen; Durand existiert nicht, und die Anweisung bewirkt nichts;
- Zeile 28: [orElseThrow] gibt den Wert zurück, wenn er vorhanden ist, oder löst eine [NoSuchElementException] aus, wenn [Optional] leer ist. Das verwendet man, wenn man sicher ist, dass der Wert vorhanden ist;
- Zeilen 32–36: Eine Person ohne Vornamen wird vom Konstruktor abgelehnt;
- Zeilen 38–43: Die Verwendung einer Null-Referenz löst die Ausnahme [NullPointerException] aus. Seit Java 14 benennt ihre Meldung den Null-Ausdruck genau.
Ergebnisse:
[Optional] ist für Rückgabewerte von Methoden gedacht; für Felder oder Parameter wird es nicht verwendet. In diesem Kurs dokumentieren wir, ob ein Wert optional ist, prüfen erforderliche Parameter mit [Objects.requireNonNull] und bevorzugen Objekte, die stets vollständig sind (mit allen erforderlichen Werten erzeugt), gegenüber Objekten, die schrittweise befüllt werden.
4.15. Beispielanwendung – V2
Wir greifen die im vorigen Kapitel behandelte Steuerberechnung (Version 1) erneut auf und setzen sie nun mit Klassen und Schnittstellen um. Rufen wir uns die Aufgabenstellung in Erinnerung. Wir wollen ein Programm schreiben, das die Steuer eines Steuerpflichtigen berechnet. Wir betrachten den vereinfachten Fall eines Steuerpflichtigen, der nur sein Gehalt zu versteuern hat (der Steuertarif von 2004 für die Einkünfte von 2003, unverändert übernommen: Dies ist eine Übung):
- Wir berechnen die Anzahl der Anteile des Arbeitnehmers: Anteile = nbChildren / 2 + 1, wenn er unverheiratet ist, nbChildren / 2 + 2, wenn er verheiratet ist, wobei nbChildren die Anzahl seiner Kinder ist;
- Hat er mindestens drei Kinder, erhält er einen zusätzlichen halben Anteil;
- sein zu versteuerndes Einkommen R wird berechnet als R = 0.72 × S, wobei S sein Jahresgehalt ist;
- sein Familienquotient wird berechnet als QF = R / Anteile;
- seine Steuer I wird anhand der folgenden Tabelle berechnet:
Grenze | coeffR | coeffN |
4962 | 0 | 0 |
8382 | 0.068 | 291.09 |
14,753 | 0.191 | 1,322.92 |
23,888 | 0.283 | 2,668.39 |
38,868 | 0.374 | 4,846.98 |
47,932 | 0.426 | 6,883.66 |
0 | 0.481 | 9,505.54 |
Jede Zeile hat drei Felder. Um die Steuer I zu berechnen, suchen Sie die erste Zeile, in der QF ≤ Grenze gilt. Ist zum Beispiel QF = 5,000, wird die Zeile (8,382; 0.068; 291.09) gefunden. Die Steuer I ist dann gleich 0.068 × R - 291.09 × Anteile. Ist QF so beschaffen, dass die Bedingung QF ≤ Grenze nie erfüllt ist, werden die Koeffizienten der letzten Zeile verwendet, sodass sich die Steuer I = 0.481 × R - 9,505.54 × Anteile ergibt.
Die Anwendung erzeugt die Datei [TaxV2]. Die Berechnungsklassen sind in einem Paket namens [tax] organisiert:
Zunächst definieren wir einen Typ, der eine Zeile des vorherigen Arrays kapseln kann, [TaxBracket.java]:
Wir verwenden einen Record:
- weil eine Stufe ein kleines Datenstück ohne Identität ist, das allein durch seinen Wert definiert ist, und es keinen Grund gibt, es nach der Erzeugung zu ändern: Ein Record ist unveränderlich;
- weil der Compiler den Konstruktor, die Zugriffsmethoden, [toString], und den Gleichheitsoperator aus einer einzigen Zeile erzeugt.
Die Komponenten haben den Typ [BigDecimal] (Paket [java.math], daher der Import in Zeile 3). Die Typen [float] und [double] stellen Zahlen binär dar: Eine Dezimalzahl wie 0.068 hat darin keine exakte Darstellung, und bei Berechnungen sammeln sich kleine Rundungsfehler an. Die Klasse [BigDecimal] stellt Dezimalzahlen exakt dar: Dies ist der Typ, der für Beträge zu verwenden ist. Ihr Nachteil ist das Fehlen von Operatoren: Wir schreiben [a.add(b)], [a.multiply(b)], [a.compareTo(b)].
Als Nächstes definieren wir eine Schnittstelle [ITax], die die Steuer berechnen kann, [ITax.java]:
- Zeile 5: Die Methode zur Berechnung der Steuer auf Grundlage von drei Angaben: Familienstand des Steuerpflichtigen, Anzahl der Kinder und Jahresgehalt. Sie rundet die Steuer auf den nächsten vollen Euro ab.
Als Nächstes definieren wir eine abstrakte Klasse, die diese Schnittstelle implementiert, [AbstractTax.java]:
- Zeile 1: Die Klasse gehört zum Paket [tax]; ihre Datei liegt daher im Ordner [tax];
- Zeile 7: Die Klasse [AbstractTax] implementiert die Schnittstelle [ITax];
- Zeile 10: Die Tarifdaten werden von einer geschützten abstrakten Methode bereitgestellt. Die Klasse [AbstractTax] weiß nicht, woher diese Daten stammen (im Code geschrieben, aus einer Datei gelesen, aus einer Datenbank usw.). Das überlässt sie den abgeleiteten Klassen. Deshalb ist sie als abstrakt deklariert, was ihre Instanziierung verhindert. Die abstrakte Methode zwingt die abgeleiteten Klassen, die Stufen bereitzustellen; der Compiler prüft das;
- Zeilen 13–35: die Implementierung der Methode [calculate] der Schnittstelle [ITax]. Abgeleitete Klassen müssen diese Methode nicht neu schreiben. Die Klasse [AbstractTax] dient somit als Faktorisierungsklasse für die abgeleiteten Klassen: Sie enthält, was allen gemeinsam ist;
- Zeilen 16–17: die Anzahl der Anteile. [BigDecimal.valueOf(n)] wandelt eine Ganzzahl in [BigDecimal] um; die Division durch [BigDecimal.TWO] ist exakt (3 / 2 = 1.5), anders als die Ganzzahldivision durch [nbChildren / 2] (3 / 2 = 1). Der Ausdruck [married ? 2 : 1] ergibt 2 für einen verheirateten Steuerpflichtigen, sonst 1;
- Zeilen 18–20: der zusätzliche halbe Anteil. Ein [BigDecimal] ist unveränderlich: [add] liefert ein neues Objekt, das der Variablen zugewiesen werden muss;
- Zeilen 22–23: zu versteuerndes Einkommen und Familienquotient. Dezimalkonstanten werden aus Zeichenketten erzeugt ([new BigDecimal("0.72")]), damit sie exakt sind. Die Division eines [BigDecimal] kann unendlich viele Nachkommastellen ergeben (1 / 3): Wir geben die gewünschte Genauigkeit an, hier [MathContext.DECIMAL128] (34 signifikante Stellen);
- Zeilen 25–32: Suche nach der Stufe. Standardmäßig ist dies die letzte Stufe ([brackets.getLast()], Zeile 26). Die Schleife durchläuft alle Stufen außer der letzten und endet ([break]) bei der ersten Stufe, deren Grenze größer oder gleich dem Familienquotienten ist, was mit [compareTo(...) <= 0] geprüft wird;
- Zeile 34: die Steuerberechnung. Die Methode [intValue] schneidet das Ergebnis auf seinen ganzzahligen Anteil ab.
Eine Klasse, die die Schnittstelle [ITax] implementiert, kann durch Ableitung von der Klasse [AbstractTax] erstellt werden. Das tun wir jetzt mit [HardwiredTax.java]:
- Zeilen 9–11: Die Klasse [HardwiredTax] enthält die zur Steuerberechnung erforderlichen Daten fest im Code. Es sind Klassenfelder ([static]) [final]: Sie werden von allen Instanzen gemeinsam genutzt und können nicht durch andere Arrays ersetzt werden. Üblicherweise werden die Namen von Konstanten ([static final]) in Großbuchstaben geschrieben;
- Zeilen 17–26: Der Konstruktor erstellt aus diesen Daten die Liste der Steuerstufen. [BigDecimal.valueOf(double)] (Zeilen 21–22) wandelt ein [double] über seine kürzeste Dezimaldarstellung in ein [BigDecimal] um: [BigDecimal.valueOf(0.068)] ist genau 0.068. Verwenden Sie nicht den Konstruktor [new BigDecimal(0.068)], der alle Dezimalstellen des angenäherten Binärwerts wiedergibt (0.068000000000000004884981308350688 …);
- Zeile 25: [List.copyOf] gibt eine schreibgeschützte Kopie der Liste zurück: Keine Klasse kann den Tarif ändern;
- Zeilen 29–32: Die abstrakte Methode der Elternklasse wird implementiert: Sie gibt die Liste der Stufen zurück.
Im nächsten Kapitel kommen weitere von [AbstractTax] abgeleitete Klassen hinzu, die die Stufen aus einer Textdatei oder aus JSON lesen: Sie müssen lediglich die Methode [getTaxBrackets] bereitstellen.
Ein Testprogramm könnte das folgende [Main.java] sein:
Mit dem obigen Programm kann der Benutzer wiederholt Simulationen der Steuerberechnung durchführen.
- Zeilen 4–5: Das Hauptprogramm liegt im unbenannten Paket; es importiert die beiden Typen, die es benötigt, aus dem Paket [tax]. Diese Typen müssen öffentlich sein;
- Zeilen 7–11: Die Hilfemeldung ist eine Konstante der impliziten Klasse, geschrieben als Textblock (Java 15), der von drei Anführungszeichen begrenzt wird: Die Zeichenkette kann sich über mehrere Zeilen erstrecken, und die gemeinsame Einrückung der Zeilen wird entfernt. Da das schließende Anführungszeichen am Ende der letzten Zeile steht, endet die Zeichenkette nicht mit einem Zeilenumbruch;
- Zeile 15: Erzeugung eines [tax]-Objekts, das die Schnittstelle [ITax] implementiert. Dieses Objekt entsteht durch Instanziierung eines Typs [HardwiredTax], eines Typs, der die Schnittstelle [ITax] implementiert. Beachten Sie, dass der Variablen [tax] nicht der Typ [HardwiredTax] , sondern der Typ [ITax] zugewiesen wurde. Damit zeigen wir an, dass uns nur die Methode [calculate] des Objekts [tax] interessiert und nicht der Rest. Um Daten aus einer Datei zu verwenden, muss nur diese eine Zeile geändert werden;
- Zeilen 18–53: die Schleife für die Simulationen der Steuerberechnung;
- Zeilen 20–21: Die drei Parameter, die die Methode [calculate] benötigt, werden in einer einzigen über die Tastatur eingegebenen Zeile abgefragt. [IO.readln(message)] zeigt die Meldung an und liest dann eine Zeile; es gibt [null] zurück, wenn die Standardeingabe geschlossen ist: Die Prüfung in Zeile 23 beendet dann das Programm, ebenso wie eine leere Zeile;
- Zeile 27: Die Methode [split] zerlegt die Zeile – von führenden und nachgestellten Leerzeichen befreit – in Wörter, die durch ein oder mehrere Leerzeichen getrennt sind (regulärer Ausdruck ["\\s+"]);
- Zeilen 40 und 46: Die Methode [positiveInteger] (Zeilen 57–64) prüft, ob die letzten beiden Felder positive Ganzzahlen oder null sind. [Integer.parseInt] löst eine [NumberFormatException] aus, wenn die Zeichenkette keine Ganzzahl darstellt: Die Methode fängt sie ab und gibt -1 zurück, was einen Fehler anzeigt;
- Zeile 52: Aufruf der Methode [calculate] des Objekts [tax], das die Schnittstelle [ITax] implementiert.
Hier ein Beispiel für die Ausführung des Programms, gestartet im Ordner [TaxV2]:
Die Steuerbeträge werden korrekt berechnet: 4.282 Euro für einen verheirateten Steuerpflichtigen mit zwei Kindern und einem Jahresgehalt von 60.000 Euro (Zeile 26) und 2.959 Euro bei drei Kindern (Zeile 28). Ein unverheirateter Steuerpflichtiger ohne Kinder zahlt für dasselbe Gehalt 11.519 Euro (Zeile 30).
Im Vergleich zu Version 1 ist die Berechnung nun hinter einer Schnittstelle in Klassen gekapselt: Das Dialogprogramm kennt nur noch die Schnittstelle [ITax]. Die folgenden Versionen nutzen diese Trennung: Version 3 (nächstes Kapitel) ändert die Datenquelle, indem neue Klassen von [AbstractTax] abgeleitet werden, und anschließend wird die Anwendung in Schichten organisiert (Kapitel 6).