Skip to content

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]:

1
2
3
Persons/
  Person.java       the Person class
  Main.java         the main program

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“):

1
2
3
4
5
6
> javac -d classes *.java
> ls classes
Main.class
Person.class
> java -cp classes Main
[Jean, Dupont, 30]

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:

public class Person {
    // Attribute (Felder)
    private String firstName = "";
    private String lastName = "";
    private int age;

    // Methode
    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

    // Methode
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 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:

1
2
3
4
5
6
> java Main.java
Main.java:4: error: firstName has private access in Person
    p1.firstName = "Jean";
      ^
1 error
error: compilation failed

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.

1
2
3
4
5
6
> java Main.java
Main.java:4: error: variable p1 might not have been initialized
    p1.initialize("Jean", "Dupont", 30);
    ^
1 error
error: compilation failed

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:

1
2
3
> java Main.java
Exception in thread "main" java.lang.NullPointerException: Cannot invoke "Person.initialize(String, String, int)" because "<local1>" is null
    at Main.main(Main.java:4)

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]:

    public void initialize(String p, String n, int age) {
        this.firstName = p;
        this.lastName = n;
        this.age = age;
    }

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]:

1
2
3
4
5
6
7
// das Hauptprogramm
void main() {
    // ein Objekt Person
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
}
  • 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:

> java Main.java
[Jean, Dupont, 30]

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:

1
2
3
4
> javac -d classes Classes01.java
> ls classes
Classes01$Person.class
Classes01.class

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:

// Überladung der Methode initialize
void main() {
    Person p1 = new Person();
    p1.initialize("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person();
    p2.initialize(p1);
    p2.identify();
}

// die Klasse Person wird nach der Methode main deklariert
class Person {
    // Attribute
    private String firstName = "";
    private String lastName = "";
    private int age;

    // Initialisierung aus drei Werten
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // Initialisierung aus einer anderen Person
    public void initialize(Person p) {
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // Identität der Person
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 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:

1
2
3
> java Classes01.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]

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]:

// Konstruktoren der Klasse Person
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    p1.identify();
    Person p2 = new Person(p1);
    p2.identify();
    Person p3 = new Person();
    p3.identify();
}

class Person {
    // Attribute
    private String firstName;
    private String lastName;
    private int age;

    // Hauptkonstruktor
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // Kopierkonstruktor: Er ruft den Hauptkonstruktor auf
    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // parameterloser Konstruktor: Er ruft ebenfalls den Hauptkonstruktor auf
    public Person() {
        this("?", "?", 0);
    }

    // Identität der Person
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 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:

1
2
3
4
> java Classes02.java
[Jean, Dupont, 30]
[Jean, Dupont, 30]
[?, ?, 0]

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]:

// Objektreferenzen
void main() {
    // p1
    Person p1 = new Person("Jean", "Dupont", 30);
    IO.print("p1="); p1.identify();
    // p2 referenziert dasselbe Objekt wie p1
    Person p2 = p1;
    IO.print("p2="); p2.identify();
    // p3 referenziert ein Objekt, das eine Kopie des von p1 referenzierten Objekts ist
    Person p3 = new Person(p1);
    IO.print("p3="); p3.identify();
    // wir ändern den Zustand des von p1 referenzierten Objekts
    p1.initialize("Micheline", "Benoît", 67);
    IO.print("p1="); p1.identify();
    // da p2 = p1 gilt, hat das von p2 referenzierte Objekt seinen Zustand geändert
    IO.print("p2="); p2.identify();
    // p3 referenziert nicht dasselbe Objekt wie p1: Das von p3 referenzierte Objekt hat sich nicht geändert
    IO.print("p3="); p3.identify();
    // sind p1 und p2 dieselbe Referenz? und p1 und p3?
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1 == p3 : " + (p1 == p3));
}

class Person {
    // Attribute
    private String firstName;
    private String lastName;
    private int age;

    // Konstruktoren
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // Initialisierung
    public void initialize(String p, String n, int age) {
        firstName = p;
        lastName = n;
        this.age = age;
    }

    // Identität der Person
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}

Die Methode [IO.print] (Zeilen 5, 8, …) schreibt ihren Parameter ohne Zeilenumbruch. Ergebnisse:

1
2
3
4
5
6
7
8
> java Classes03.java
p1=[Jean, Dupont, 30]
p2=[Jean, Dupont, 30]
p3=[Jean, Dupont, 30]
p1=[Micheline, Benoît, 67]
p2=[Micheline, Benoît, 67]
p3=[Jean, Dupont, 30]
p1 == p2 : true, p1 == p3 : false

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:

// Übergabe von Parametern des Typs Objektreferenz
void main() {
    StringBuilder sb0 = new StringBuilder("test0"), sb1 = new StringBuilder("test1");
    IO.println("In calling function before call: sb0=" + sb0 + ", sb1=" + sb1);
    StringBuilder sb2 = changeStringBuilder(sb0, sb1);
    IO.println("In calling function after call: sb0=" + sb0 + ", sb1=" + sb1 + ", sb2=" + sb2);
}

// die aufgerufene Funktion
StringBuilder changeStringBuilder(StringBuilder sbf0, StringBuilder sbf1) {
    IO.println("Start of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1);
    // wir verändern das von sbf0 referenzierte Objekt
    sbf0.append("*****");
    // sbf1 referenziert jetzt ein neues Objekt
    sbf1 = new StringBuilder("test1*****");
    // ein neues Objekt wird an den Aufrufer zurückgegeben
    StringBuilder sbf2 = new StringBuilder("test2*****");
    IO.println("End of called function: sbf0=" + sbf0 + ", sbf1=" + sbf1 + ", sbf2=" + sbf2);
    return sbf2;
}
  • 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:

1
2
3
4
5
> java Classes04.java
In calling function before call: sb0=test0, sb1=test1
Start of called function: sbf0=test0, sbf1=test1
End of called function: sbf0=test0*****, sbf1=test1*****, sbf2=test2*****
In calling function after call: sb0=test0*****, sb1=test1, sb2=test2*****

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:

// temporäre Objekte
void main() {
    new Person(new Person("Jean", "Dupont", 30)).identify();
}

class Person {
    // Attribute
    private String firstName;
    private String lastName;
    private int age;

    // Konstruktoren
    public Person(String firstName, String lastName, int age) {
        IO.println("Constructor Person(String, String, int)");
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person(Person p) {
        IO.println("Constructor Person(Person)");
        firstName = p.firstName;
        lastName = p.lastName;
        age = p.age;
    }

    // Identität der Person
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 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:

1
2
3
4
> java Classes05.java
Constructor Person(String, String, int)
Constructor Person(Person)
[Jean, Dupont, 30]

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:

// Methoden zum Lesen (Getter) und Schreiben (Setter) privater Attribute
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
}

class Person {
    // Attribute
    private String firstName;
    private String lastName;
    private int age;

    // Konstruktor
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // Getter
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // Setter
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }
}
  • Zeilen 23–33: die lesenden Methoden, Getter genannt;
  • Zeilen 36–46: schreibende Methoden, „Setter“ genannt.

Ergebnisse:

1
2
3
> java Classes06.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)

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]:

// Setter, die die Gültigkeit der empfangenen Werte prüfen
void main() {
    Person p = new Person("Jean", "Michelin", 34);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    p.setAge(56);
    IO.println("p=(" + p.getFirstName() + "," + p.getLastName() + "," + p.getAge() + ")");
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // parameterloser Konstruktor, dann Aufrufe der Setter
    Person p2 = new Person();
    p2.setAge(7);
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    IO.println("p2=(" + p2.getFirstName() + "," + p2.getLastName() + "," + p2.getAge() + ")");
    try {
        Person p3 = new Person();
        p3.setFirstName("Paul");
        p3.setLastName(" ");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
}

class Person {
    // Attribute
    private String firstName = "";
    private String lastName = "";
    private int age;

    // Konstruktoren
    public Person(String firstName, String lastName, int age) {
        // wir gehen über die Setter, um von ihren Prüfungen zu profitieren
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
    }

    public Person() {
    }

    // Getter
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // Setter: Sie sind als final deklariert, weil der Konstruktor sie aufruft
    public final void setFirstName(String firstName) {
        // gültiger Vorname?
        if (firstName == null || firstName.isBlank()) {
            throw new IllegalArgumentException("first name (" + firstName + ") invalid");
        }
        this.firstName = firstName;
    }

    public final void setLastName(String lastName) {
        // gültiger Nachname?
        if (lastName == null || lastName.isBlank()) {
            throw new IllegalArgumentException("last name (" + lastName + ") invalid");
        }
        this.lastName = lastName;
    }

    public final void setAge(int age) {
        // gültiges Alter?
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }
}

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:

1
2
3
4
5
6
> java Classes07.java
p=(Jean,Michelin,34)
p=(Jean,Michelin,56)
age (-4) invalid
p2=(Arthur,Martin,7)
last name ( ) invalid

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:

// final-Felder, nur lesbar, Pflichtparameter
void main() {
    Person p = new Person("Jean", "Dupont", 30, "Angers");
    IO.println(p.getIdentity());
    // der Vorname ist les- und schreibbar
    p.setFirstName("Jacques");
    // das Alter kann nur innerhalb der Klasse geändert werden
    p.growOlder();
    IO.println(p.getIdentity());
    // die folgenden Zeilen werden vom Compiler abgelehnt
    // p.setLastName("Durand"); // es gibt keinen Setter für den Nachnamen
    // p.setAge(40);         // es gibt keinen Setter für das Alter
    // p.city = "Paris";     // das Feld city ist final

    // ein Pflichtparameter
    Contact c = new Contact("jean.dupont@example.com");
    IO.println("Contact: " + c.getEmail() + ", " + c.getPhone());
    try {
        Contact c2 = new Contact(null);
        IO.println("Contact: " + c2.getEmail());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

class Person {
    // Felder
    private String firstName;
    // final-Felder: Sie erhalten ihren Wert ein für alle Mal im Konstruktor
    private final String lastName;
    private final String city;
    private int age;

    // Konstruktor
    public Person(String firstName, String lastName, int age, String city) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        this.city = city;
    }

    // Vorname les- und schreibbar
    public String getFirstName() {
        return firstName;
    }

    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    // Nachname, Alter und Stadt nur lesbar
    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    public String getCity() {
        return city;
    }

    // ein berechneter Wert
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + ", " + city + "]";
    }

    // das Alter wird nur von den Methoden der Klasse geändert
    public void growOlder() {
        age++;
    }
}

class Contact {
    // die E-Mail ist Pflicht, das Telefon optional
    private final String email;
    private final String phone;

    // Konstruktor mit beiden Werten
    public Contact(String email, String phone) {
        this.email = Objects.requireNonNull(email, "the email is mandatory");
        this.phone = phone;
    }

    // Konstruktor ohne das Telefon: Standardwert
    public Contact(String email) {
        this(email, "unknown");
    }

    public String getEmail() {
        return email;
    }

    public String getPhone() {
        return phone;
    }
}
  • 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:

1
2
3
4
5
> java Classes08.java
[Jean, Dupont, 30, Angers]
[Jacques, Dupont, 31, Angers]
Contact: jean.dupont@example.com, unknown
Error: the email is mandatory

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:

// „Fluent"-Setter: Sie geben das aktuelle Objekt zurück
void main() {
    Person p = new Person().setFirstName("  jean ").setLastName("Dupont").setAge(30);
    IO.println(p.getIdentity());
    try {
        p.setLastName("");
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        p.setAge(-4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    IO.println(p.getIdentity());
}

class Person {
    // Felder
    private String firstName = "";
    private String lastName = "";
    private int age;

    // Fluent-Setter: Jeder gibt das aktuelle Objekt (this) zurück
    public Person setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
        return this;
    }

    public Person setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
        return this;
    }

    public Person setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
        return this;
    }

    // Identität
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // eine Pflichtzeichenkette prüfen: Sie wird ohne führende und nachgestellte Leerzeichen zurückgegeben
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}
  • 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:

1
2
3
4
5
> java Classes09.java
[jean, Dupont, 30]
last name () invalid
age (-4) invalid
[jean, Dupont, 30]

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]*:

// Klassenmember (static)
void main() {
    Person p1 = new Person("Jean", "Dupont", 30);
    Person p2 = new Person(p1);
    new Person(p1);
    IO.println("Number of persons created: " + Person.getNbPersons());
    // eine Klassenmethode
    Person p3 = Person.unknown();
    p3.identify();
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// statische verschachtelte Klasse: siehe die Erläuterungen
static class Person {
    // Klassenattribut
    private static long nbPersons;

    // Klassen-Getter
    public static long getNbPersons() {
        return nbPersons;
    }

    // Klassenmethode
    public static Person unknown() {
        return new Person("?", "?", 0);
    }

    // Instanzattribute
    private String firstName;
    private String lastName;
    private int age;

    // Konstruktoren
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
        nbPersons++;
    }

    public Person(Person p) {
        this(p.firstName, p.lastName, p.age);
    }

    // Identität der Person
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 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:

1
2
3
4
> java Classes10.java
Number of persons created: 3
[?, ?, 0]
Number of persons created: 4

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]:

// ein Array von Personen
void main() {
    Person[] friends = new Person[3];
    friends[0] = new Person("Jean", "Dupont", 30);
    friends[1] = new Person("Sylvie", "Vartan", 52);
    friends[2] = new Person("Neil", "Armstrong", 66);
    // Anzeige
    for (Person friend : friends) {
        friend.identify();
    }
}

class Person {
    // Attribute
    private String firstName;
    private String lastName;
    private int age;

    // Konstruktor
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    // Identität der Person
    public void identify() {
        IO.println("[" + firstName + ", " + lastName + ", " + age + "]");
    }
}
  • 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:

1
2
3
4
> java Classes11.java
[Jean, Dupont, 30]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]

4.1.20. Typinferenz und Array-Initialisierung

Das Programm [Classes12.java] enthält zwei Konstrukte, die die Erzeugung von Objekten und Arrays vereinfachen:

// Typinferenz mit var und Array-Initialisierung
void main() {
    // der Typ der Variablen wird aus dem Ausdruck abgeleitet, der sie initialisiert
    var p1 = new Person("Jean", "Dupont", 30);
    var p2 = new Person();
    p2.setFirstName("Arthur");
    p2.setLastName("Martin");
    p2.setAge(7);
    // ein Array, das mit einer Liste von Werten in geschweiften Klammern erzeugt und initialisiert wird
    Person[] friends = {
        p1,
        p2,
        new Person("Sylvie", "Vartan", 52),
        new Person("Neil", "Armstrong", 66),
    };
    for (var friend : friends) {
        IO.println(friend.getIdentity());
    }
    // ein anonymes Array, das als Parameter übergeben wird
    display(new Person[] { new Person("Pauline", "Leduc", 12), p1 });
}

// eine Methode, die ein Array von Personen empfängt
void display(Person[] persons) {
    for (Person p : persons) {
        IO.println("Display: " + p.getIdentity());
    }
}

class Person {
    // Felder
    private String firstName = "";
    private String lastName = "";
    private int age;

    // Konstruktoren
    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public Person() {
    }

    // Setter
    public void setFirstName(String firstName) {
        this.firstName = firstName;
    }

    public void setLastName(String lastName) {
        this.lastName = lastName;
    }

    public void setAge(int age) {
        this.age = age;
    }

    // Identität
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • 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:

1
2
3
4
5
6
7
> java Classes12.java
[Jean, Dupont, 30]
[Arthur, Martin, 7]
[Sylvie, Vartan, 52]
[Neil, Armstrong, 66]
Display: [Pauline, Leduc, 12]
Display: [Jean, Dupont, 30]

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]:

public class Person {
    // Klassenfeld: die Anzahl der erzeugten Personen
    private static long nbPersons;

    // Instanzfelder
    private String firstName;
    private String lastName;
    private int age;

    // Konstruktor
    public Person(String firstName, String lastName, int age) {
        setFirstName(firstName);
        setLastName(lastName);
        setAge(age);
        nbPersons++;
        IO.println("Constructor Person(String, String, int)");
    }

    // Anzahl der erzeugten Personen
    public static long getNbPersons() {
        return nbPersons;
    }

    // Getter
    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // Setter
    public final void setFirstName(String firstName) {
        this.firstName = check(firstName, "first name");
    }

    public final void setLastName(String lastName) {
        this.lastName = check(lastName, "last name");
    }

    public final void setAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
        this.age = age;
    }

    // Identität der Person
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // eine Pflichtzeichenkette prüfen
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value;
    }
}
  • 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]:

public class Teacher extends Person {
    // für die Klasse Teacher spezifisches Feld
    private int section;

    // Konstruktor
    public Teacher(String firstName, String lastName, int age, int section) {
        // Konstruktion des Person-Teils des Objekts
        super(firstName, lastName, age);
        // wir speichern die Sektion
        this.section = section;
        // Ablaufverfolgung
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // Getter und Setter der Sektion
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }
}

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:

1
2
3
4
5
6
7
8
    public Teacher(String firstName, String lastName, int age, int section) {
        // Konstruktion des Person-Teils des Objekts
        super(firstName, lastName, age);
        // wir speichern die Sektion
        this.section = section;
        // Ablaufverfolgung
        IO.println("Constructor Teacher(String, String, int, int)");
    }

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:

1
2
3
4
5
6
7
8
9
> java Main.java
.../Inheritance1/Teacher.java:6: error: constructor Person in class Person cannot be applied to given types;
    public Teacher(String firstName, String lastName, int age, int section) {
                                                                            ^
  required: String,String,int
  found:    no arguments
  reason: actual and formal argument lists differ in length
1 error
error: compilation failed

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:

void main() {
    // ein Lehrer
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    // die von der Klasse Person geerbte Methode getIdentity
    IO.println(e.getIdentity());
    // die für die Klasse Teacher spezifische Methode getSection
    IO.println("section=" + e.getSection());
    // eine Person
    Person p = new Person("Jean", "Dupont", 30);
    // die Methode display empfängt eine Person oder ein Objekt einer abgeleiteten Klasse
    display(e);
    display(p);
    // die von der Klasse Object geerbte Methode toString
    IO.println(e.toString());
    IO.println(p.toString());
    IO.println("Number of persons created: " + Person.getNbPersons());
}

// zeigt die Identität von p an
void display(Person p) {
    IO.println(p.getIdentity());
}
  • 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:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
[Lucile, Dumas, 56]
section=61
Constructor Person(String, String, int)
[Lucile, Dumas, 56]
[Jean, Dupont, 30]
Teacher@70325e14
Person@37ceb1df
Number of persons created: 2

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:

1
2
3
void display(Person p) {
    IO.println(p.getIdentity());
}

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:

    // Identität der Person: in der Klasse Teacher überschriebene Methode
    public String getIdentity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // Überschreiben der Methode toString der Klasse Object
    @Override
    public String toString() {
        return getIdentity();
    }
  • 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:

// eine finale Klasse: Von ihr kann nicht abgeleitet werden
public final class Teacher extends Person {
    // für die Klasse Teacher spezifisches Feld
    private int section;

    // Konstruktor
    public Teacher(String firstName, String lastName, int age, int section) {
        super(firstName, lastName, age);
        this.section = section;
        IO.println("Constructor Teacher(String, String, int, int)");
    }

    // Getter und Setter der Sektion
    public int getSection() {
        return section;
    }

    public void setSection(int section) {
        this.section = section;
    }

    // die Methode getIdentity überschreibt die der Elternklasse
    @Override
    public String getIdentity() {
        return "Teacher[" + super.getIdentity() + "," + section + "]";
    }
}
  • 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]:

Image

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:

void main() {
    // ein Lehrer
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    display(e);
    // eine Person
    Person p = new Person("Jean", "Dupont", 30);
    display(p);
    // als Person gesehen, bleibt der Lehrer ein Lehrer
    Person pe = e;
    IO.println(pe.getIdentity());
    IO.println(((Person) e).getIdentity());
    // IO.println(Object) zeigt das Ergebnis der Methode toString des Objekts an
    IO.println(e);
    IO.println(p);
    // ein Array von Personen unterschiedlicher Typen
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }
}

// zeigt die Identität von p an
void display(Person p) {
    IO.println(p.getIdentity());
}

Ergebnisse:

> java Main.java
Constructor Person(String, String, int)
Constructor Teacher(String, String, int, int)
Teacher[[Lucile, Dumas, 56],61]
Constructor Person(String, String, int)
[Jean, Dupont, 30]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
Teacher[[Lucile, Dumas, 56],61]
[Jean, Dupont, 30]
Person : [Jean, Dupont, 30]
Teacher : Teacher[[Lucile, Dumas, 56],61]

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:

1
2
3
4
5
6
7
8
    // IO.println(Object) zeigt das Ergebnis der Methode toString des Objekts an
    IO.println(e);
    IO.println(p);
    // ein Array von Personen unterschiedlicher Typen
    Person[] persons = { p, e };
    for (Person person : persons) {
        IO.println(person.getClass().getSimpleName() + " : " + person);
    }

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:

// finale Klassen und versiegelte Klassen (Java 17)
void main() {
    Person[] persons = {
        new Teacher("Lucile", "Dumas", 61),
        new Student("Paul", "Martin", "computer science"),
        new Adjunct("Marc", "Petit"),
        new Consultant("Lise", "Morel", "Airbus"),
    };
    for (Person p : persons) {
        IO.println(p.getClass().getSimpleName() + " : " + p.getIdentity());
    }
    // die erlaubten direkten Unterklassen der versiegelten Klasse Person
    IO.println("Person is sealed: " + Person.class.isSealed());
    for (Class<?> c : Person.class.getPermittedSubclasses()) {
        IO.println("permitted subclass: " + c.getSimpleName());
    }
}

// eine versiegelte Klasse: Nur die nach permits aufgeführten Klassen können von ihr ableiten
abstract sealed class Person permits Teacher, Student, Adjunct {
    private final String firstName;
    private final String lastName;

    protected Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    public String getIdentity() {
        return "[" + firstName + ", " + lastName + "]";
    }
}

// eine von einer versiegelten Klasse abgeleitete Klasse muss final, sealed oder non-sealed sein
final class Teacher extends Person {
    private final int section;

    public Teacher(String firstName, String lastName, int section) {
        super(firstName, lastName);
        this.section = section;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", section " + section;
    }
}

final class Student extends Person {
    private final String major;

    public Student(String firstName, String lastName, String major) {
        super(firstName, lastName);
        this.major = major;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", major " + major;
    }
}

// non-sealed: Ab dieser Klasse ist die Hierarchie wieder offen
non-sealed class Adjunct extends Person {
    public Adjunct(String firstName, String lastName) {
        super(firstName, lastName);
    }
}

// eine von Adjunct abgeleitete Klasse: erlaubt, da Adjunct nicht versiegelt ist
class Consultant extends Adjunct {
    private final String company;

    public Consultant(String firstName, String lastName, String company) {
        super(firstName, lastName);
        this.company = company;
    }

    @Override
    public String getIdentity() {
        return super.getIdentity() + ", company " + company;
    }
}

// vom Compiler abgelehnt: Artist ist in der permits-Klausel von Person nicht aufgeführt
// final class Artist extends Person { ... }
  • 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:

1
2
3
4
5
6
7
8
9
> java Classes13.java
Teacher : [Lucile, Dumas], section 61
Student : [Paul, Martin], major computer science
Adjunct : [Marc, Petit]
Consultant : [Lise, Morel], company Airbus
Person is sealed: true
permitted subclass: Teacher
permitted subclass: Student
permitted subclass: Adjunct

Wenn Sie die Klasse [Artist] wieder einkommentieren (indem Sie ihr einen Konstruktor hinzufügen), meldet der Compiler:

1
2
3
4
5
6
> java Classes13.java
Classes13.java:86: error: class is not allowed to extend sealed class: Classes13.Person (as it is not listed in its 'permits' clause)
final class Artist extends Person { Artist() { super("a", "b"); } }
      ^
1 error
error: compilation failed

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]:

import java.util.ArrayList;
import java.util.List;
import java.util.StringJoiner;

public class ListOfPersons {
    // die Personen der Liste
    private final List<Person> persons = new ArrayList<>();

    // Anzahl der Personen in der Liste
    public int size() {
        return persons.size();
    }

    // das Äquivalent eines Operators +: gibt eine neue Liste zurück, die die Personen
    // der aktuellen Liste und die Person p enthält
    public ListOfPersons plus(Person p) {
        ListOfPersons result = new ListOfPersons();
        result.persons.addAll(persons);
        result.persons.add(p);
        return result;
    }

    // das Äquivalent eines Operators +=: fügt p zur aktuellen Liste hinzu, die zurückgegeben wird
    public ListOfPersons add(Person p) {
        persons.add(p);
        return this;
    }

    // das Äquivalent eines Indexers: Lesen und Schreiben des Elements Nr. i
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // Position der Person mit dem angegebenen Nachnamen, -1, wenn sie nicht existiert
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }

    // toString: gibt (person1,person2,...) zurück
    @Override
    public String toString() {
        StringJoiner joiner = new StringJoiner(",", "(", ")");
        for (Person p : persons) {
            joiner.add(p.toString());
        }
        return joiner.toString();
    }
}
  • 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:

void main() {
    // - Methoden statt Operatoren
    String s1 = "jean";
    String s2 = new StringBuilder("je").append("an").toString();
    IO.println("s1 == s2 : " + (s1 == s2) + ", s1.equals(s2) : " + s1.equals(s2));
    IO.println("s1.compareTo(\"paul\") : " + s1.compareTo("paul"));
    BigDecimal a = new BigDecimal("0.10"), b = new BigDecimal("0.20");
    IO.println("a + b = " + a.add(b) + ", a < b : " + (a.compareTo(b) < 0));

    // - die Methode plus
    // eine Liste von Personen
    ListOfPersons l = new ListOfPersons();
    // Personen hinzufügen
    l = l.plus(new Person("jean", "martin", 10)).plus(new Person("pauline", "leduc", 12));
    // Anzeige
    IO.println("l=" + l);
    // l.plus(p) gibt eine neue Liste zurück: l wird nicht verändert
    ListOfPersons l2 = l.plus(new Person("louis", "durand", 8));
    IO.println("l=" + l);
    IO.println("l2=" + l2);

    // - die Methode add
    ListOfPersons l3 = l;
    // add verändert die von l referenzierte Liste, ohne eine neue Liste zu erzeugen
    l.add(new Teacher("camille", "germain", 27, 60));
    IO.println("l=" + l);
    // l und l3 referenzieren weiterhin dasselbe Objekt
    IO.println("l3 == l : " + (l3 == l));
  • 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):

1
2
3
4
5
6
7
8
9
> java Main.java
s1 == s2 : false, s1.equals(s2) : true
s1.compareTo("paul") : -6
a + b = 0.30, a < b : true
l=([jean, martin, 10],[pauline, leduc, 12])
l=([jean, martin, 10],[pauline, leduc, 12])
l2=([jean, martin, 10],[pauline, leduc, 12],[louis, durand, 8])
l=([jean, martin, 10],[pauline, leduc, 12],Teacher[[camille, germain, 27],60])
l3 == l : true

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:

    // das Äquivalent eines Indexers: Lesen und Schreiben des Elements Nr. i
    public Person get(int i) {
        return persons.get(i);
    }

    public void set(int i, Person p) {
        persons.set(i, p);
    }

    // Position der Person mit dem angegebenen Nachnamen, -1, wenn sie nicht existiert
    public int indexOf(String lastName) {
        for (int i = 0; i < persons.size(); i++) {
            if (persons.get(i).getLastName().equals(lastName)) {
                return i;
            }
        }
        return -1;
    }
  • 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:

    // - die Methoden get, set und indexOf statt Indexern
    // Element Nr. 1 ändern
    l.set(1, new Person("franck", "gallon", 5));
    // Element Nr. 1 anzeigen
    IO.println("l.get(1)=" + l.get(1));
    // die Liste l anzeigen
    IO.println("l=" + l);
    // Personen anhand ihres Nachnamens suchen
    String[] lastNames = { "martin", "germain", "xx" };
    for (String lastName : lastNames) {
        int index = l.indexOf(lastName);
        if (index != -1) {
            IO.println("Person(" + lastName + ")=" + l.get(index));
        } else {
            IO.println("Person(" + lastName + ") does not exist");
        }
    }
  • 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):

1
2
3
4
5
6
...
l.get(1)=[franck, gallon, 5]
l=([jean, martin, 10],[franck, gallon, 5],Teacher[[camille, germain, 27],60])
Person(martin)=[jean, martin, 10]
Person(germain)=Teacher[[camille, germain, 27],60]
Person(xx) does not exist

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:

// primitive Typen und Referenztypen: Kopie des Werts, Kopie der Referenz
void main() {
    // zwei Variablen primitiven Typs
    int age1 = 10;
    int age2 = age1;
    IO.println("age1=" + age1 + ", age2=" + age2);
    // age2 wird verändert
    age2 = 30;
    // age1 und age2 prüfen
    IO.println("age1=" + age1 + ", age2=" + age2);

    // ein Objekt op1
    CPerson op1 = new CPerson();
    op1.name = "paul";
    op1.age = 10;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    // ein Objekt op2
    CPerson op2 = op1;
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");
    // op2 wird verändert
    op2.name = "nicole";
    op2.age = 30;
    // op1 und op2 prüfen
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op2=CPerson(" + op2.name + "," + op2.age + ")");

    // eine explizite Kopie des Objekts
    CPerson op3 = new CPerson();
    op3.name = op1.name;
    op3.age = op1.age;
    op3.age = 50;
    IO.println("op1=CPerson(" + op1.name + "," + op1.age + ")");
    IO.println("op3=CPerson(" + op3.name + "," + op3.age + ")");
}

// Klasse CPerson
class CPerson {
    String name = "";
    int age;
}
  • 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:

1
2
3
4
5
6
7
8
9
> java Classes14.java
age1=10, age2=10
age1=10, age2=30
op1=CPerson(paul,10)
op2=CPerson(paul,10)
op1=CPerson(nicole,30)
op2=CPerson(nicole,30)
op1=CPerson(nicole,30)
op3=CPerson(nicole,50)

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).

Image

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:

// Gleichheit zweier Objekte: equals und hashCode
void main() {
    Person p1 = new Person("paul", 10);
    Person p2 = new Person("paul", 10);
    Person p3 = new Person("nicole", 30);
    // == vergleicht die Referenzen, equals vergleicht die Werte
    IO.println("p1 == p2 : " + (p1 == p2) + ", p1.equals(p2) : " + p1.equals(p2)
            + ", p1.equals(p3) : " + p1.equals(p3));
    // zwei gleiche Objekte haben denselben Hashcode
    IO.println("p1.hashCode() == p2.hashCode() : " + (p1.hashCode() == p2.hashCode()));
    // eine Menge (Set) enthält keine zwei gleichen Objekte
    Set<Person> persons = new HashSet<>();
    persons.add(p1);
    persons.add(p2);
    persons.add(p3);
    IO.println("size of the set: " + persons.size());
    IO.println("the set contains (paul,10): " + persons.contains(new Person("paul", 10)));
}

class Person {
    // Felder
    private final String name;
    private final int age;

    // Konstruktor
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    // zwei Personen sind gleich, wenn sie denselben Namen und dasselbe Alter haben
    @Override
    public boolean equals(Object o) {
        // dasselbe Objekt?
        if (this == o) {
            return true;
        }
        // ist o eine Person (und nicht null)?
        if (!(o instanceof Person other)) {
            return false;
        }
        // Vergleich der Felder
        return age == other.age && Objects.equals(name, other.name);
    }

    // mit equals konsistenter Hashcode
    @Override
    public int hashCode() {
        return Objects.hash(name, age);
    }

    @Override
    public String toString() {
        return "Person(" + name + "," + age + ")";
    }
}
  • 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:

1
2
3
4
5
> java Classes15.java
p1 == p2 : false, p1.equals(p2) : true, p1.equals(p3) : false
p1.hashCode() == p2.hashCode() : true
size of the set: 2
the set contains (paul,10): true

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:

// unveränderliche Objekte: eine unveränderliche Klasse und ein Record
void main() {
    Point a = new Point(1, 2);
    // a.x = 5;   // abgelehnt: das Feld x ist final
    Point b = a.move(3, 4);
    IO.println("a=" + a + ", b=" + b);

    // ein Record: Konstruktor, Accessoren, toString, equals und hashCode werden generiert
    Color red = new Color(255, 0, 0);
    Color red2 = new Color(255, 0, 0);
    IO.println("red=" + red + ", r=" + red.r());
    IO.println("red.equals(red2) : " + red.equals(red2) + ", red == red2 : " + (red == red2));
    // eine veränderte Kopie, erzeugt durch handgeschriebene Methoden
    Color pink = red.withG(128).withB(128);
    IO.println("red=" + red + ", pink=" + pink);
}

// eine unveränderliche Klasse: final, private und finale Felder, kein Setter
final class Point {
    private final int x;
    private final int y;

    public Point(int x, int y) {
        this.x = x;
        this.y = y;
    }

    public int getX() {
        return x;
    }

    public int getY() {
        return y;
    }

    // wir verändern den Punkt nicht: Wir geben einen neuen zurück
    public Point move(int dx, int dy) {
        return new Point(x + dx, y + dy);
    }

    @Override
    public String toString() {
        return "(" + x + "," + y + ")";
    }
}

// ein Record: eine in einer Zeile deklarierte unveränderliche Klasse ... oder fast
record Color(int r, int g, int b) {
    // Methoden, die eine veränderte Kopie des Records zurückgeben
    public Color withG(int g) {
        return new Color(r, g, b);
    }

    public Color withB(int b) {
        return new Color(r, g, b);
    }
}
  • 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:

1
2
3
4
5
> java Classes16.java
a=(1,2), b=(4,6)
red=Color[r=255, g=0, b=0], r=255
red.equals(red2) : true, red == red2 : false
red=Color[r=255, g=0, b=0], pink=Color[r=255, g=128, b=128]

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]:

1
2
3
4
5
6
7
public interface IStats {
    // Mittelwert einer Wertereihe
    double average();

    // Standardabweichung der Reihe
    double standardDeviation();
}

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]:

1
2
3
// ein Student
public record Student(String firstName, String lastName) {
}

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]:

1
2
3
4
5
6
7
// die Note eines Studenten
public record Grade(Student student, double value) {
    @Override
    public String toString() {
        return "[" + student.firstName() + "," + student.lastName() + "," + value + "]";
    }
}

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]:

import java.util.Arrays;

public class ArrayOfGrades implements IStats {
    // Felder
    private final String subject;
    private final Grade[] grades;
    private final double average;
    private final double standardDeviation;

    // Konstruktor
    public ArrayOfGrades(String subject, Grade[] grades) {
        // die Daten speichern
        this.subject = subject;
        this.grades = grades;
        // den Mittelwert der Noten berechnen
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        average = grades.length != 0 ? sum / grades.length : -1;
        // die Standardabweichung berechnen
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - average, 2);
        }
        standardDeviation = grades.length != 0 ? Math.sqrt(squares / grades.length) : -1;
    }

    // Getter
    public String getSubject() {
        return subject;
    }

    public Grade[] getGrades() {
        return grades;
    }

    // Implementierung der Methoden der Schnittstelle IStats
    @Override
    public double average() {
        return average;
    }

    @Override
    public double standardDeviation() {
        return standardDeviation;
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + Arrays.toString(grades);
    }
}
  • 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]:

import java.util.List;

public class ListOfGrades implements IStats {
    // Felder
    private final String subject;
    private final List<Grade> grades;
    // gespeicherter Mittelwert und gespeicherte Standardabweichung (null: noch nicht berechnet)
    private Double average;
    private Double standardDeviation;

    // Konstruktor
    public ListOfGrades(String subject, List<Grade> grades) {
        this.subject = subject;
        this.grades = grades;
    }

    // Getter
    public String getSubject() {
        return subject;
    }

    public List<Grade> getGrades() {
        return grades;
    }

    // eine Note hinzufügen
    public void add(Grade grade) {
        grades.add(grade);
        // Mittelwert und Standardabweichung müssen neu berechnet werden
        average = null;
        standardDeviation = null;
    }

    // Mittelwert der Noten: wird bei der ersten Anforderung berechnet
    @Override
    public double average() {
        if (average == null) {
            average = computeAverage();
        }
        return average;
    }

    // Standardabweichung der Noten: wird bei der ersten Anforderung berechnet
    @Override
    public double standardDeviation() {
        if (standardDeviation == null) {
            standardDeviation = computeStandardDeviation();
        }
        return standardDeviation;
    }

    private double computeAverage() {
        if (grades.isEmpty()) {
            return -1;
        }
        double sum = 0;
        for (Grade grade : grades) {
            sum += grade.value();
        }
        return sum / grades.size();
    }

    private double computeStandardDeviation() {
        if (grades.isEmpty()) {
            return -1;
        }
        double m = average();
        double squares = 0;
        for (Grade grade : grades) {
            squares += Math.pow(grade.value() - m, 2);
        }
        return Math.sqrt(squares / grades.size());
    }

    // toString
    @Override
    public String toString() {
        return "subject=" + subject + ", grades=" + grades;
    }
}
  • 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:

void main() {
    // einige Studenten und ihre Englischnoten
    Student[] students = {
        new Student("Paul", "Martin"), new Student("Maxime", "Germain"), new Student("Berthine", "Samin")
    };
    Grade[] grades = { new Grade(students[0], 14), new Grade(students[1], 16), new Grade(students[2], 18) };
    // die in einem Objekt ArrayOfGrades gespeichert sind
    ArrayOfGrades english = new ArrayOfGrades("english", grades);
    // Anzeige von Mittelwert und Standardabweichung
    displayStats(english);
    // dieselben Noten in einem Objekt ListOfGrades
    ListOfGrades french = new ListOfGrades("french", new ArrayList<>(List.of(grades)));
    displayStats(french);
    // wir fügen eine Note hinzu
    french.add(new Grade(new Student("Jérôme", "Jaric"), 10));
    displayStats(french);
    // eine Variable kann eine Schnittstelle als Typ haben
    IStats stats = english;
    IO.println("English average: " + stats.average());
    stats = french;
    IO.println("French average: " + stats.average());
}

// Anzeige von Mittelwert und Standardabweichung eines Objekts, das IStats implementiert
void displayStats(IStats values) {
    IO.println(values + ", Average=" + values.average() + ", Standard deviation=" + values.standardDeviation());
}
  • 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 Klassen Ci können dann als tatsächliche Parameter für Methoden verwendet werden, die einen formalen Parameter vom Typ I akzeptieren – das heißt für Methoden, die nur die in der Schnittstelle I definierten Methoden der Ci-Objekte verwenden und nicht die spezifischen Felder und Methoden der verschiedenen Ci-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:

1
2
3
4
5
6
> java Main.java
subject=english, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0]], Average=16.0, Standard deviation=1.632993161855452
subject=french, grades=[[Paul,Martin,14.0], [Maxime,Germain,16.0], [Berthine,Samin,18.0], [Jérôme,Jaric,10.0]], Average=14.5, Standard deviation=2.958039891549808
English average: 16.0
French average: 14.5

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:

// default- (Java 8), static- (Java 8) und private-Schnittstellenmethoden (Java 9)
void main() {
    IShape[] shapes = { new Square(2), new Circle(1), IShape.unitSquare() };
    for (IShape shape : shapes) {
        IO.println(shape.description());
    }
    // die default-Methode wird von der Klasse Square geerbt
    Square square = new Square(3);
    IO.println(square.description());
}

interface IShape {
    // abstrakte Methode: zu implementieren
    double area();

    // Methode mit Standardimplementierung
    default String description() {
        return getClass().getSimpleName() + " with area " + format(area());
    }

    // statische Methode: Sie wird mit dem Namen der Schnittstelle aufgerufen
    static IShape unitSquare() {
        return new Square(1);
    }

    // private Methode: nur von den Methoden der Schnittstelle verwendbar
    private String format(double value) {
        return String.format("%.2f", value);
    }
}

// Square verwendet die Standardimplementierung von description
// (statische Klasse, da die Schnittstelle Quadrate erzeugt: siehe Classes10)
static class Square implements IShape {
    private final double side;

    public Square(double side) {
        this.side = side;
    }

    @Override
    public double area() {
        return side * side;
    }
}

// Circle liefert seine eigene Implementierung von description
class Circle implements IShape {
    private final double radius;

    public Circle(double radius) {
        this.radius = radius;
    }

    @Override
    public double area() {
        return Math.PI * radius * radius;
    }

    @Override
    public String description() {
        return String.format("Circle with radius %s and area %.2f", radius, area());
    }
}
  • 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:

1
2
3
4
5
> java Classes17.java
Square with area 4,00
Circle with radius 1.0 and area 3,14
Square with area 1,00
Square with area 9,00

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:

public abstract class User {
    // Felder
    private final String login;
    private final String password;
    private final String role;

    // Konstruktor
    @SuppressWarnings("this-escape")
    protected User(String login, String password) throws UnknownUserException {
        // wir speichern die Informationen
        this.login = login;
        this.password = password;
        // wir identifizieren den Benutzer
        String role = identify();
        // identifiziert?
        if (role == null) {
            throw new UnknownUserException("[" + login + "," + password + "]");
        }
        this.role = role;
    }

    // toString
    @Override
    public String toString() {
        return "User[" + login + "," + password + "," + role + "]";
    }

    // Identifizierung: liefert die Rolle des Benutzers oder null, wenn er nicht erkannt wird
    protected abstract String identify();
}
  • 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):

1
2
3
4
5
> javac -Xlint:all -d classes *.java
User.java:13: warning: [this-escape] possible 'this' escape before subclass is fully initialized
        String role = identify();
                              ^
1 warning

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:

1
2
3
4
5
6
7
8
public class UnknownUserException extends Exception {
    // Versionsnummer der Klasse (siehe die Erläuterungen)
    private static final long serialVersionUID = 1L;

    public UnknownUserException(String message) {
        super(message);
    }
}
  • 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:

public class Administrator extends User {
    // Konstruktor
    public Administrator(String login, String password) throws UnknownUserException {
        super(login, password);
    }

    // Identifizierung
    @Override
    protected String identify() {
        // LDAP-Identifizierung
        // ...
        return "admin";
    }
}
  • 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:

1
2
3
4
5
6
7
    // Identifizierung
    @Override
    protected String identify() {
        // Identifizierung über eine Datenbank
        // ...
        return "observer";
    }

Die Methode der Klasse [Unknown] gibt die Referenz [null] zurück, um anzuzeigen, dass der Benutzer nicht erkannt wurde:

1
2
3
4
5
6
7
    // Identifizierung
    @Override
    protected String identify() {
        // Benutzer unbekannt
        // ...
        return null;
    }

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:

void main() {
    try {
        IO.println(new Observer("observer", "pwd1"));
        IO.println(new Administrator("admin", "pwd2"));
        IO.println(new Unknown("xx", "yy"));
    } catch (UnknownUserException e) {
        IO.println("Unknown user: " + e.getMessage());
    }
    // User u = new User("x", "y");   // abgelehnt: die Klasse User ist abstrakt
}

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:

1
2
3
4
> java Main.java
User[observer,pwd1,observer]
User[admin,pwd2,admin]
Unknown user: [xx,yy]

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:

// generische Klassen und Methoden
void main() {
    // - eine generische Klasse Pair<T>
    // Integer
    Pair<Integer> pi = new Pair<>(1, 2);
    pi.swap();
    IO.println("pi=" + pi);
    // String
    Pair<String> ps = new Pair<>("s1", "s2");
    ps.swap();
    IO.println("ps=" + ps);
    // Person
    Person p1 = new Person("jean", "clu", 20), p2 = new Person("pauline", "dard", 55);
    Pair<Person> pp = new Pair<>(p1, p2);
    pp.swap();
    IO.println("pp=" + pp);
    // das erste Element ist vom Typ Person: keine Umwandlung
    Person first = pp.getFirst();
    IO.println("first element: " + first);

    // - eine generische Methode Generic2.swap<T>
    Integer[] integers = { 1, 2, 3 };
    Generic2.<Integer>swap(integers, 0, 2);
    IO.println("integers=" + Arrays.toString(integers));
    // der Compiler leitet T aus dem Typ der tatsächlichen Parameter ab
    Person[] persons = { p1, p2 };
    Generic2.swap(persons, 0, 1);
    IO.println("persons=" + Arrays.toString(persons));

    // - eine generische Klasse mit Zustand: ein Stapel von Elementen des Typs T
    MyStack<Person> stack = new MyStack<>();
    stack.push(p1);
    stack.push(p2);
    IO.println("The stack contains " + stack.size() + " persons");
    Person top = stack.pop();
    IO.println("Popped person: " + top + ", " + stack.size() + " left");
    // stack.push("x");   // abgelehnt: der Stapel akzeptiert nur Person-Objekte
}

// eine generische Klasse: ein Paar aus zwei Elementen des Typs T
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    // die beiden Elemente werden vertauscht
    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// eine nicht generische Klasse mit einer generischen Methode
class Generic2 {
    // vertauscht die Elemente Nr. i und j eines Arrays von Elementen des Typs T
    public static <T> void swap(T[] array, int i, int j) {
        T temp = array[i];
        array[i] = array[j];
        array[j] = temp;
    }
}

// ein Stapel von Elementen des Typs T
class MyStack<T> {
    // die Elemente des Stapels
    private final List<T> elements = new ArrayList<>();

    // Anzahl der Elemente
    public int size() {
        return elements.size();
    }

    // ein Element oben auf den Stapel legen
    public void push(T element) {
        elements.add(element);
    }

    // das oberste Element vom Stapel entfernen
    public T pop() {
        if (elements.isEmpty()) {
            throw new IllegalStateException("empty stack");
        }
        return elements.removeLast();
    }
}

// eine Person
record Person(String firstName, String lastName, int age) {
    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}
  • 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:

1
2
3
4
5
6
7
8
9
> java Classes18.java
pi=(2,1)
ps=(s2,s1)
pp=([pauline, dard, 55],[jean, clu, 20])
first element: [pauline, dard, 55]
integers=[3, 2, 1]
persons=[[pauline, dard, 55], [jean, clu, 20]]
The stack contains 2 persons
Popped person: [pauline, dard, 55], 1 left

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:

// die Schranken generischer Parameter
void main() {
    // - T ist immer ein Objekttyp: int wird durch Integer ersetzt
    Pair<Integer> pi = new Pair<>(1, 2);
    // Pair<int> pe = new Pair<>(1, 2);   // Fehler: int ist ein primitiver Typ
    IO.println("pi=" + pi);

    // - die Schranke T extends IValue
    // Ordnen von Paaren von Objekten des Typs RandomValue
    for (int i = 0; i < 5; i++) {
        Pair<RandomValue> pair = new Pair<>(new RandomValue(), new RandomValue());
        IO.print("Before --> " + pair);
        Generic4.order(pair);
        IO.println("   After --> " + pair);
    }
    // Ordnen eines Paars von Objekten des Typs StringValue
    Pair<StringValue> strings = new Pair<>(new StringValue("xxxxxxxxxxxxxx"), new StringValue("xx"));
    IO.println("Before --> " + strings);
    Generic4.order(strings);
    IO.println("After --> " + strings);
    // Generic4.order(pi);   // Fehler: Integer implementiert IValue nicht
}

// ein Paar aus zwei Elementen des Typs T
class Pair<T> {
    private T first;
    private T second;

    public Pair(T first, T second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public T getSecond() {
        return second;
    }

    public void swap() {
        T temp = first;
        first = second;
        second = temp;
    }

    @Override
    public String toString() {
        return "(" + first + "," + second + ")";
    }
}

// der Typ T muss IValue implementieren
class Generic4 {
    public static <T extends IValue> void order(Pair<T> pair) {
        // wenn das 1. Element größer als das 2. ist, werden die Elemente vertauscht
        if (pair.getFirst().value() > pair.getSecond().value()) {
            pair.swap();
        }
    }
}

// ein Objekt mit einem ganzzahligen Wert
interface IValue {
    int value();
}

// ein Objekt mit einem Zufallswert
class RandomValue implements IValue {
    // Zufallszahlengenerator, den alle Instanzen gemeinsam nutzen
    // (mit festem Seed initialisiert, damit die Ergebnisse reproduzierbar sind)
    private static final Random generator = new Random(2026);
    // Wert des Objekts
    private final int value = generator.nextInt(100);

    @Override
    public int value() {
        return value;
    }

    @Override
    public String toString() {
        return String.valueOf(value);
    }
}

// ein Objekt, dessen Wert die Länge einer Zeichenkette ist
class StringValue implements IValue {
    private final String s;

    public StringValue(String s) {
        this.s = s;
    }

    @Override
    public int value() {
        return s.length();
    }

    @Override
    public String toString() {
        return s;
    }
}
  • 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:

1
2
3
4
5
6
7
8
9
> java Classes19.java
pi=(1,2)
Before --> (99,50)   After --> (50,99)
Before --> (97,30)   After --> (30,97)
Before --> (49,38)   After --> (38,49)
Before --> (73,36)   After --> (36,73)
Before --> (34,78)   After --> (34,78)
Before --> (xxxxxxxxxxxxxx,xx)
After --> (xx,xxxxxxxxxxxxxx)

Hier sind die Fehler, die bei der Ausführung des Programms entstehen, nachdem die Zeilen 5 und 21 auskommentiert wurden:

> java Classes19.java
Classes19.java:5: error: unexpected type
    Pair<int> pe = new Pair<>(1, 2);   // error: int is a primitive type
         ^
  required: reference
  found:    int
Classes19.java:21: error: method order in class Classes19.Generic4 cannot be applied to given types;
    Generic4.order(pi);   // error: Integer does not implement IValue
            ^
  required: Classes19.Pair<T>
  found:    Classes19.Pair<Integer>
  reason: inference variable T has incompatible bounds
    equality constraints: Integer
    upper bounds: IValue
  where T is a type-variable:
    T extends IValue declared in method <T>order(Classes19.Pair<T>)
2 errors
error: compilation failed

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:

// die generischen Schnittstellen Comparable<T> und Comparator<T>: ein Array von Personen sortieren
void main() {
    Person[] persons = {
        new Person("claude", "pollon", 25),
        new Person("valentine", "germain", 35),
        new Person("paul", "germain", 32),
    };
    // Anzeige
    display("Array to sort", persons);
    // Sortierung nach der natürlichen Ordnung der Personen (Comparable): das Alter
    Arrays.sort(persons);
    display("Array after sorting by age", persons);
    // Sortierung nach Nachname und Vorname (Comparator)
    Arrays.sort(persons, new CompareNames());
    display("Array after sorting by last and first names", persons);
    // Sortierung nach absteigendem Alter, mit einer anonymen Klasse
    Arrays.sort(persons, new Comparator<Person>() {
        @Override
        public int compare(Person p1, Person p2) {
            return Integer.compare(p2.getAge(), p1.getAge());
        }
    });
    display("Array after sorting by descending age", persons);
}

// Anzeige eines Arrays von Personen
void display(String text, Person[] persons) {
    IO.println(text + "-".repeat(50 - text.length()));
    for (Person p : persons) {
        IO.println(p);
    }
}

// eine Person, vergleichbar mit einer anderen Person
class Person implements Comparable<Person> {
    private final String firstName;
    private final String lastName;
    private final int age;

    public Person(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public int getAge() {
        return age;
    }

    // die natürliche Ordnung der Personen: die Reihenfolge der Alter
    @Override
    public int compareTo(Person other) {
        return Integer.compare(age, other.age);
    }

    @Override
    public String toString() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }
}

// Vergleich von Nachname und Vorname zweier Personen
class CompareNames implements Comparator<Person> {
    // Vergleich von Zeichenketten nach den Regeln der französischen Sprache
    private final Collator collator = Collator.getInstance(Locale.FRENCH);

    @Override
    public int compare(Person p1, Person p2) {
        // wir vergleichen die Nachnamen
        int i = collator.compare(p1.getLastName(), p2.getLastName());
        if (i != 0) {
            return i;
        }
        // gleiche Nachnamen: Wir vergleichen die Vornamen
        return collator.compare(p1.getFirstName(), p2.getFirstName());
    }
}
  • 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:

> java Classes20.java
Array to sort-------------------------------------
[claude, pollon, 25]
[valentine, germain, 35]
[paul, germain, 32]
Array after sorting by age------------------------
[claude, pollon, 25]
[paul, germain, 32]
[valentine, germain, 35]
Array after sorting by last and first names-------
[paul, germain, 32]
[valentine, germain, 35]
[claude, pollon, 25]
Array after sorting by descending age-------------
[valentine, germain, 35]
[paul, germain, 32]
[claude, pollon, 25]

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:

// Wildcards, Schranken und Type Erasure
void main() {
    List<Integer> integers = List.of(1, 2, 3);
    List<Double> reals = List.of(1.5, 2.25);
    // ? extends Number: eine Liste von Elementen eines von Number abgeleiteten Typs
    IO.println("Sum of integers: " + sum(integers));
    IO.println("Sum of reals: " + sum(reals));
    // ? super Integer: eine Liste, die Integer aufnehmen kann
    List<Number> numbers = new ArrayList<>();
    addIntegers(numbers, 3);
    numbers.add(2.5);
    IO.println("numbers=" + numbers + ", sum=" + sum(numbers));
    // eine rekursive Schranke: T muss mit sich selbst vergleichbar sein
    IO.println("max : " + max(List.of("paul", "jean", "valentine")) + ", " + max(integers));
    // Type Erasure: Zur Laufzeit ist eine Liste eine Liste
    List<String> l1 = new ArrayList<>();
    List<Integer> l2 = new ArrayList<>();
    IO.println("same class: " + (l1.getClass() == l2.getClass()) + " (" + l1.getClass().getName() + ")");
}

// Summe der Elemente einer Liste von Zahlen
double sum(List<? extends Number> values) {
    double sum = 0;
    for (Number value : values) {
        sum += value.doubleValue();
    }
    // values.add(1);   // abgelehnt: der genaue Typ der Elemente ist unbekannt
    return sum;
}

// die ganzen Zahlen 1, 2, ..., n zu einer Liste hinzufügen, die Integer aufnehmen kann
void addIntegers(List<? super Integer> list, int n) {
    for (int i = 1; i <= n; i++) {
        list.add(i);
    }
}

// das größte Element einer nicht leeren Liste
<T extends Comparable<? super T>> T max(List<T> elements) {
    T max = elements.getFirst();
    for (T element : elements) {
        if (element.compareTo(max) > 0) {
            max = element;
        }
    }
    return max;
}
  • 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:

1
2
3
4
5
6
> java Classes21.java
Sum of integers: 6.0
Sum of reals: 3.75
numbers=[1, 2, 3, 2.5], sum=8.5
max : valentine, 3
same class: true (java.util.ArrayList)

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:

1
2
3
4
5
6
Namespaces/
  Main.java             the main program (unnamed package)
  e1/
    Person.java         the class e1.Person
  e2/
    Person.java         the class e2.Person

Die erste Klasse, [Person] [e1/Person.java]:

// die Klassen dieser Datei gehören zum Paket e1
package e1;

public class Person {
    private final String firstName;
    private final String lastName;

    public Person(String firstName, String lastName) {
        this.firstName = firstName;
        this.lastName = lastName;
    }

    @Override
    public String toString() {
        return "e1.Person[" + firstName + ", " + lastName + "]";
    }
}

Die zweite: [e2/Person.java]:

// die Klassen dieser Datei gehören zum Paket e2
package e2;

public class Person {
    private final String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }

    @Override
    public String toString() {
        return "e2.Person[" + name + "]";
    }
}

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:

// eine Klasse aus einem Paket importieren
import e1.Person;
// statischer Import eines statischen Members einer Klasse
import static java.lang.Math.sqrt;

void main() {
    // Person bezeichnet e1.Person, das importiert wurde
    Person p1 = new Person("Jean", "Dupont");
    // der vollständige Name einer Klasse beseitigt jede Mehrdeutigkeit
    e2.Person p2 = new e2.Person("Durand");
    IO.println(p1 + " " + p2);
    // vollständiger Name und Paket einer Klasse
    IO.println(Person.class.getName() + ", " + e2.Person.class.getName());
    IO.println("package of the Person class: " + Person.class.getPackageName());
    // das Modul, das eine Klasse enthält
    IO.println("e1.Person is in a named module: " + Person.class.getModule().isNamed());
    IO.println(String.class.getName() + " is in the module " + String.class.getModule().getName());
    // StringBuilder ist dank des automatischen Imports des Moduls java.base bekannt
    StringBuilder sb = new StringBuilder("abc");
    IO.println(sb.append("def"));
    // sqrt ist dank des statischen Imports bekannt
    IO.println("sqrt(2)=" + sqrt(2));
}
  • 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:

1
2
3
4
5
6
7
8
> java Main.java
e1.Person[Jean, Dupont] e2.Person[Durand]
e1.Person, e2.Person
package of the Person class: e1
e1.Person is in a named module: false
java.lang.String is in the module java.base
abcdef
sqrt(2)=1.4142135623730951

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:

1
2
3
4
5
6
> java Main.java
Main.java:9: error: reference to Person is ambiguous
    Person p1 = new Person("Jean", "Dupont");
    ^
  both class e2.Person in e2 and class e1.Person in e1 match
...

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:

// Records (Java 16)
void main() {
    Person r1 = new Person("Jean", "Dupont", 30);
    Person r2 = new Person("Jean", "Dupont", 30);
    // vom Compiler generiertes toString
    IO.println(r1);
    // die Accessoren haben den Namen der Komponenten
    IO.println("first name=" + r1.firstName() + ", identity=" + r1.identity());
    // Gleichheit nach Wert: r1 und r2 sind zwei verschiedene, aber gleiche Objekte
    IO.println("r1.equals(r2) : " + r1.equals(r2) + ", r1 == r2 : " + (r1 == r2));
    // die Komponenten sind nur lesbar
    // r1.age = 31;   // abgelehnt: das Feld age ist final
    // eine veränderte Kopie, mit einer „Wither"-Methode
    Person r3 = r1.withAge(31);
    IO.println(r3);
    IO.println("r1.equals(r3) : " + r1.equals(r3));
    // Dekonstruktion in Variablen mit einem Record-Pattern (Java 21)
    if (r1 instanceof Person(String firstName, String lastName, int age)) {
        IO.println("first name=" + firstName + ", last name=" + lastName + ", age=" + age);
    }

    // dasselbe mit einer Klasse
    PersonC c1 = new PersonC("Jean", "Dupont", 30);
    PersonC c2 = new PersonC("Jean", "Dupont", 30);
    IO.println(c1);
    IO.println("c1.equals(c2) : " + c1.equals(c2));

    // zwei Records, die dieselbe Schnittstelle implementieren
    Teacher e = new Teacher("Lucile", "Dumas", 56, 61);
    IO.println(e);
    IO.println(e.identity());
    // die Gleichheit berücksichtigt den Typ: Eine Person ist nicht gleich einem Teacher
    Person pe = new Person("Lucile", "Dumas", 56);
    IO.println("pe.equals(e) : " + pe.equals(e));
    // der gemeinsame Typ: die Schnittstelle HasIdentity
    HasIdentity[] identities = { pe, e };
    for (HasIdentity i : identities) {
        IO.println(i.identity());
    }
}

// eine von den Records implementierte Schnittstelle
interface HasIdentity {
    String identity();
}

// ein Record: firstName, lastName, age sind seine Komponenten
record Person(String firstName, String lastName, int age) implements HasIdentity {
    // Methoden können hinzugefügt werden
    @Override
    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // eine „Wither"-Methode: eine Kopie, in der sich eine Komponente geändert hat
    public Person withAge(int age) {
        return new Person(firstName, lastName, age);
    }
}

// ein Record kann nicht von einem anderen Record ableiten
record Teacher(String firstName, String lastName, int age, int section) implements HasIdentity {
    @Override
    public String identity() {
        return "Teacher[[" + firstName + ", " + lastName + ", " + age + "]," + section + "]";
    }
}

// eine äquivalente Klasse ... oder fast
final class PersonC {
    private final String firstName;
    private final String lastName;
    private final int age;

    public PersonC(String firstName, String lastName, int age) {
        this.firstName = firstName;
        this.lastName = lastName;
        this.age = age;
    }

    public String firstName() {
        return firstName;
    }

    public String lastName() {
        return lastName;
    }

    public int age() {
        return age;
    }
}
  • 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:

> java Classes22.java
Person[firstName=Jean, lastName=Dupont, age=30]
first name=Jean, identity=[Jean, Dupont, 30]
r1.equals(r2) : true, r1 == r2 : false
Person[firstName=Jean, lastName=Dupont, age=31]
r1.equals(r3) : false
first name=Jean, last name=Dupont, age=30
Classes22$PersonC@206a70ef
c1.equals(c2) : false
Teacher[firstName=Lucile, lastName=Dumas, age=56, section=61]
Teacher[[Lucile, Dumas, 56],61]
pe.equals(e) : false
[Lucile, Dumas, 56]
Teacher[[Lucile, Dumas, 56],61]

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:

// Record-Konstruktoren: kompakter Konstruktor, andere Konstruktoren
void main() {
    Person p = new Person("  Jean ", "Dupont", 30);
    IO.println(p.identity());
    // ein Record ist unveränderlich: growOlder gibt eine neue Person zurück
    Person p2 = p.growOlder();
    IO.println(p.identity() + " -> " + p2.identity());
    // ein weiterer Konstruktor
    Person unknown = new Person("Martin");
    IO.println(unknown.identity());
    // die Prüfungen des kompakten Konstruktors
    try {
        new Person("Paul", " ", 20);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    try {
        new Person("Paul", "Martin", -4);
    } catch (IllegalArgumentException ex) {
        IO.println(ex.getMessage());
    }
    // ein Record mit einer Methode und einer statischen Factory
    Point pt = new Point(3, 4);
    IO.println("pt=" + pt + ", distance to the origin: " + pt.distance() + ", origin=" + Point.origin());
}

record Person(String firstName, String lastName, int age) {
    // kompakter Konstruktor: Er prüft und normalisiert die Parameter,
    // die Felder werden anschließend automatisch initialisiert
    Person {
        firstName = check(firstName, "first name");
        lastName = check(lastName, "last name");
        if (age < 0) {
            throw new IllegalArgumentException("age (" + age + ") invalid");
        }
    }

    // jeder andere Konstruktor muss den kanonischen Konstruktor aufrufen
    Person(String lastName) {
        this("?", lastName, 0);
    }

    // eine Methode, die eine neue Person zurückgibt
    public Person growOlder() {
        return new Person(firstName, lastName, age + 1);
    }

    public String identity() {
        return "[" + firstName + ", " + lastName + ", " + age + "]";
    }

    // eine statische Prüfmethode
    private static String check(String value, String label) {
        if (value == null || value.isBlank()) {
            throw new IllegalArgumentException(label + " (" + value + ") invalid");
        }
        return value.strip();
    }
}

record Point(double x, double y) {
    // ein statisches Feld ist erlaubt, kein Instanzfeld
    private static final Point ORIGIN = new Point(0, 0);

    public static Point origin() {
        return ORIGIN;
    }

    public double distance() {
        return Math.sqrt(x * x + y * y);
    }
}
  • 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:

1
2
3
4
5
6
7
> java Classes23.java
[Jean, Dupont, 30]
[Jean, Dupont, 30] -> [Jean, Dupont, 31]
[?, Martin, 0]
last name ( ) invalid
age (-4) invalid
pt=Point[x=3.0, y=4.0], distance to the origin: 5.0, origin=Point[x=0.0, y=0.0]

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:

// keine Erweiterungsmethoden in Java: statische Hilfsmethoden
import static java.lang.Character.toUpperCase;

void main() {
    Person p = new Person("jean", "dupont", 30);
    // die Hilfsmethoden werden mit dem Namen ihrer Klasse aufgerufen
    IO.println(Tools.initials(p));
    IO.println(Tools.firstUpper("jean"));
    IO.println(Tools.fullName(p) + " is an adult: " + Tools.isAdult(p));
    IO.println("\"it is sunny\" has " + Tools.nbWords("it is sunny") + " words");
    // eine statische Methode des Records selbst
    Person unknown = Person.unknown();
    IO.println(Tools.fullName(unknown) + " is an adult: " + Tools.isAdult(unknown));
}

// eine Person
record Person(String firstName, String lastName, int age) {
    // statische Factory: eine unbekannte Person
    static Person unknown() {
        return new Person("?", "?", 0);
    }
}

// eine Hilfsklasse: final, privater Konstruktor, statische Methoden
final class Tools {
    private Tools() {
    }

    static String initials(Person p) {
        return toUpperCase(p.firstName().charAt(0)) + "." + toUpperCase(p.lastName().charAt(0)) + ".";
    }

    static String firstUpper(String s) {
        return s.isEmpty() ? s : toUpperCase(s.charAt(0)) + s.substring(1);
    }

    static boolean isAdult(Person p) {
        return p.age() >= 18;
    }

    static String fullName(Person p) {
        return firstUpper(p.firstName()) + " " + p.lastName().toUpperCase();
    }

    static int nbWords(String s) {
        return s.isBlank() ? 0 : s.strip().split("\\s+").length;
    }
}
  • 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:

1
2
3
4
5
6
> java Classes24.java
J.D.
Jean
Jean DUPONT is an adult: true
"it is sunny" has 3 words
? ? is an adult: false

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:

// Pattern Matching auf Objekten
void main() {
    Object[] objects = {
        new Individual("Jean", "Dupont", 30),
        new Individual("Lise", "Morel", 12),
        new Teacher("Lucile", "Dumas", 56, 61),
        new Teacher("Marc", "Petit", 44, 27),
        new Student("Paul", "Martin", 19, "computer science"),
        "a string",
        42,
        null,
    };

    // 1 - das Typ-Pattern: instanceof Type variable (Java 16)
    for (Object o : objects) {
        if (o instanceof Person p) {
            // hier ist p eine Person
            IO.println(p.firstName() + " is of type " + p.getClass().getSimpleName());
        }
    }

    // 2 - das Typ-Pattern gefolgt von einer Bedingung
    for (Object o : objects) {
        if (o instanceof Person p && p.age() >= 18) {
            IO.println(p.firstName() + " is an adult");
        }
    }

    // 3 - das switch auf dem Typ des Objekts, mit Guards und Record-Patterns (Java 21)
    for (Object o : objects) {
        IO.println(describe(o));
    }

    // 4 - ein erschöpfendes switch auf einer versiegelten Schnittstelle
    for (Object o : objects) {
        if (o instanceof Person p) {
            IO.println(p.firstName() + " : " + category(p));
        }
    }
}

String describe(Object o) {
    return switch (o) {
        case Teacher e when e.section() == 27 -> e.firstName() + " teaches computer science";
        case Teacher e -> e.firstName() + " teaches in section " + e.section();
        case Student(var firstName, _, _, var major) -> firstName + " studies " + major;
        case Person p when p.age() < 18 -> p.firstName() + " is a minor";
        case Person p -> p.firstName() + " is " + p.age() + " years old";
        case String s -> "a string of " + s.length() + " characters";
        case Integer n when n > 0 -> "the positive integer " + n;
        case null -> "the null reference";
        default -> "an unknown object";
    };
}

// kein default: Der Compiler weiß, dass die drei Fälle alle Personen abdecken
String category(Person p) {
    return switch (p) {
        case Individual _ -> "individual";
        case Teacher _ -> "teacher";
        case Student _ -> "student";
    };
}

// eine versiegelte Schnittstelle und die drei Records, die sie implementieren
sealed interface Person permits Individual, Teacher, Student {
    String firstName();
    String lastName();
    int age();
}

record Individual(String firstName, String lastName, int age) implements Person {
}

record Teacher(String firstName, String lastName, int age, int section) implements Person {
}

record Student(String firstName, String lastName, int age, String major) implements Person {
}
  • 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:

> java Classes25.java
Jean is of type Individual
Lise is of type Individual
Lucile is of type Teacher
Marc is of type Teacher
Paul is of type Student
Jean is an adult
Lucile is an adult
Marc is an adult
Paul is an adult
Jean is 30 years old
Lise is a minor
Lucile teaches in section 61
Marc teaches computer science
Paul studies computer science
a string of 8 characters
the positive integer 42
the null reference
Jean : individual
Lise : individual
Lucile : teacher
Marc : teacher
Paul : student

Wenn der Fall [Student] aus der Methode [category] entfernt wird, meldet der Compiler einen Fehler:

1
2
3
4
5
6
> java Classes25.java
Classes25.java:58: error: the switch expression does not cover all possible input values
    return switch (p) {
           ^
1 error
error: compilation failed

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:

// Behandlung des Werts null: Optional, Objects.requireNonNull ...
void main() {
    Person jean = new Person("Jean", "Dupont");
    jean.setMiddleName("Marie");
    Person[] persons = { jean, new Person("Paul", "Martin") };
    for (Person p : persons) {
        // ein Standardwert, wenn die Referenz null ist
        String middle = Objects.requireNonNullElse(p.getMiddleName(), "(none)");
        // ein expliziter Test
        String length = p.getMiddleName() == null ? "null" : String.valueOf(p.getMiddleName().length());
        IO.println(p.getFirstName() + " : middle name=" + middle + ", length=" + length);
    }

    // eine Methode, die möglicherweise nichts findet: Sie gibt ein Optional<Person> zurück
    Optional<Person> found = find(persons, "Durand");
    IO.println("Durand found: " + found.isPresent());
    IO.println(found.map(Person::getFirstName).orElse("Durand: person not found"));
    // wir testen das Vorhandensein eines Werts, bevor wir ihn verwenden
    found = find(persons, "Martin");
    if (found.isPresent()) {
        IO.println("Martin : " + found.get().getFirstName());
    }
    // ifPresent: Die Aktion wird nur ausgeführt, wenn ein Wert vorhanden ist
    find(persons, "Dupont").ifPresent(p -> p.setMiddleName("Louise"));
    find(persons, "Durand").ifPresent(p -> p.setMiddleName("Louise"));
    IO.println(jean.getMiddleName());
    // orElseThrow: Wir behaupten, dass der Wert vorhanden ist, andernfalls wird eine Exception ausgelöst
    Person martin = find(persons, "Martin").orElseThrow();
    IO.println(martin.getFirstName());

    // Objects.requireNonNull: ein Pflichtparameter
    try {
        new Person(null, "Morel");
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
    // die NullPointerException und ihre detaillierte Meldung (Java 14)
    try {
        Person lise = new Person("Lise", "Morel");
        IO.println(lise.getMiddleName().length());
    } catch (NullPointerException ex) {
        IO.println("Error: " + ex.getMessage());
    }
}

// eine Person anhand des Nachnamens suchen
Optional<Person> find(Person[] persons, String lastName) {
    for (Person p : persons) {
        if (p.getLastName().equals(lastName)) {
            return Optional.of(p);
        }
    }
    return Optional.empty();
}

class Person {
    // Pflichtfelder: Sie dürfen nie null sein
    private final String firstName;
    private final String lastName;
    // optionales Feld: null bedeutet „kein zweiter Vorname"
    private String middleName;

    public Person(String firstName, String lastName) {
        this.firstName = Objects.requireNonNull(firstName, "the first name is mandatory");
        this.lastName = Objects.requireNonNull(lastName, "the last name is mandatory");
    }

    public String getFirstName() {
        return firstName;
    }

    public String getLastName() {
        return lastName;
    }

    public String getMiddleName() {
        return middleName;
    }

    public void setMiddleName(String middleName) {
        this.middleName = middleName;
    }
}
  • 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:

> java Classes26.java
Jean : middle name=Marie, length=5
Paul : middle name=(none), length=null
Durand found: false
Durand: person not found
Martin : Paul
Louise
Paul
Error: the first name is mandatory
Error: Cannot invoke "String.length()" because the return value of "Classes26$Person.getMiddleName()" is null

[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:

1
2
3
4
5
6
7
TaxV2/
  Main.java                 the program that dialogues with the user
  tax/
    TaxBracket.java         a bracket of the tax scale
    ITax.java               the tax calculation interface
    AbstractTax.java        an abstract class implementing ITax
    HardwiredTax.java       a derived class, with hard-coded data

Zunächst definieren wir einen Typ, der eine Zeile des vorherigen Arrays kapseln kann, [TaxBracket.java]:

1
2
3
4
5
6
7
package tax;

import java.math.BigDecimal;

// eine Stufe des Steuertarifs
public record TaxBracket(BigDecimal limit, BigDecimal coeffR, BigDecimal coeffN) {
}

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]:

1
2
3
4
5
6
package tax;

public interface ITax {
    // Steuerberechnung eines Steuerpflichtigen
    int calculate(boolean married, int nbChildren, int salary);
}
  • 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]:

package tax;

import java.math.BigDecimal;
import java.math.MathContext;
import java.util.List;

public abstract class AbstractTax implements ITax {
    // die für die Berechnung benötigten Steuerstufen stammen aus einer externen Quelle,
    // die nur die abgeleiteten Klassen kennen
    protected abstract List<TaxBracket> getTaxBrackets();

    // Steuerberechnung
    @Override
    public int calculate(boolean married, int nbChildren, int salary) {
        // Berechnung der Anzahl der Anteile
        BigDecimal shares = BigDecimal.valueOf(nbChildren).divide(BigDecimal.TWO)
                .add(BigDecimal.valueOf(married ? 2 : 1));
        if (nbChildren >= 3) {
            shares = shares.add(new BigDecimal("0.5"));
        }
        // Berechnung des zu versteuernden Einkommens und des Familienquotienten
        BigDecimal income = new BigDecimal("0.72").multiply(BigDecimal.valueOf(salary));
        BigDecimal quotient = income.divide(shares, MathContext.DECIMAL128);
        // Suche nach der Steuerstufe: Die letzte wird verwendet, wenn keine Grenze passt
        List<TaxBracket> brackets = getTaxBrackets();
        TaxBracket bracket = brackets.getLast();
        for (int i = 0; i < brackets.size() - 1; i++) {
            if (quotient.compareTo(brackets.get(i).limit()) <= 0) {
                bracket = brackets.get(i);
                break;
            }
        }
        // Steuerberechnung
        return income.multiply(bracket.coeffR()).subtract(shares.multiply(bracket.coeffN())).intValue();
    }
}
  • 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]:

package tax;

import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.List;

public class HardwiredTax extends AbstractTax {
    // Daten der Steuerberechnung (Steuertarif 2004 auf Einkommen 2003), „fest verdrahtet"
    private static final double[] LIMITS = { 4962, 8382, 14753, 23888, 38868, 47932, 0 };
    private static final double[] COEFF_R = { 0, 0.068, 0.191, 0.283, 0.374, 0.426, 0.481 };
    private static final double[] COEFF_N = { 0, 291.09, 1322.92, 2668.39, 4846.98, 6883.66, 9505.54 };

    // die Steuerstufen
    private final List<TaxBracket> taxBrackets;

    // Konstruktor
    public HardwiredTax() {
        // Erstellen und Füllen der Liste der Steuerstufen
        List<TaxBracket> brackets = new ArrayList<>();
        for (int i = 0; i < LIMITS.length; i++) {
            brackets.add(new TaxBracket(BigDecimal.valueOf(LIMITS[i]),
                    BigDecimal.valueOf(COEFF_R[i]), BigDecimal.valueOf(COEFF_N[i])));
        }
        // die gespeicherte Liste ist nicht veränderbar
        taxBrackets = List.copyOf(brackets);
    }

    // Implementierung der abstrakten Methode der Elternklasse
    @Override
    protected List<TaxBracket> getTaxBrackets() {
        return taxBrackets;
    }
}
  • 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:

// interaktives Steuerberechnungsprogramm
// der Benutzer gibt drei Daten über die Tastatur ein: married nbChildren salary
// das Programm zeigt dann die zu zahlende Steuer an
import tax.HardwiredTax;
import tax.ITax;

static final String SYNTAX = """
        syntax: Married NbChildren Salary
        Married: y for married, n for not married
        NbChildren: number of children
        Salary: annual salary in euros""";

void main() {
    // Erzeugung eines ITax-Objekts
    ITax tax = new HardwiredTax();

    // Eingabeschleife
    while (true) {
        // wir fragen nach den Parametern der Steuerberechnung
        String parameters = IO.readln("Tax calculation parameters in the format: "
                + "Married (y/n) NbChildren Salary, or nothing to stop: ");
        // Ende der Standardeingabe oder leere Zeile: Wir hören auf
        if (parameters == null || parameters.isBlank()) {
            break;
        }
        // Prüfung der Anzahl der Felder der eingegebenen Zeile
        String[] fields = parameters.strip().split("\\s+");
        if (fields.length != 3) {
            IO.println(SYNTAX);
            continue;
        }
        // Prüfung der Gültigkeit der Parameter
        // married
        String married = fields[0].toLowerCase();
        if (!married.equals("y") && !married.equals("n")) {
            IO.println(SYNTAX + "\nIncorrect married argument: type y or n");
            continue;
        }
        // nbChildren
        int nbChildren = positiveInteger(fields[1]);
        if (nbChildren < 0) {
            IO.println(SYNTAX + "\nIncorrect NbChildren argument: type a positive or zero integer");
            continue;
        }
        // salary
        int salary = positiveInteger(fields[2]);
        if (salary < 0) {
            IO.println(SYNTAX + "\nIncorrect salary argument: type a positive or zero integer");
            continue;
        }
        // die Parameter sind korrekt: Wir berechnen die Steuer
        IO.println("Tax=" + tax.calculate(married.equals("y"), nbChildren, salary) + " euros");
    }
}

// liefert die positive oder null betragende ganze Zahl, die die Zeichenkette darstellt, -1, wenn die Zeichenkette keine darstellt
int positiveInteger(String input) {
    try {
        int value = Integer.parseInt(input);
        return value >= 0 ? value : -1;
    } catch (NumberFormatException ex) {
        return -1;
    }
}

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]:

> java Main.java
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect married argument: type y or n
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 d
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect salary argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: q s d f
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y -1 60000
syntax: Married NbChildren Salary
Married: y for married, n for not married
NbChildren: number of children
Salary: annual salary in euros
Incorrect NbChildren argument: type a positive or zero integer
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 2 60000
Tax=4282 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: y 3 60000
Tax=2959 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: n 0 60000
Tax=11519 euros
Tax calculation parameters in the format: Married (y/n) NbChildren Salary, or nothing to stop: 

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).