Zum Inhalt springen

Generics

Die Klassen des JDK, mit denen wir in dieser Woche arbeiten, sind fast alle generisch: List<String>, Map<String, Integer>, Optional<Kunde>. Die spitzen Klammern sagen, mit welchem Typ eine Klasse arbeitet. Bevor wir die fertigen Klassen benutzen, schreiben wir selbst eine.

  • erklären, welches Problem Generics lösen
  • eine generische Klasse schreiben und benutzen
  • eine generische Methode schreiben
  • einen Typparameter mit extends einschränken

Demo-Code: 18-generics

⤓ demo-generics.zip herunterladen

Der fertige Stand aus der Vorführung – zum Nachlesen, Ausprobieren und Weiterbauen.

Entpacke die ZIP-Datei nach C:\dev\intellij. In IntelliJ: File → Open… → den Ordner 18-generics wählen → OK → Trust Project. Zeigt IntelliJ oben Project JDK is not defined: auf Setup SDK klicken und das JDK 21 wählen.

Enthält: ObjectBox.java, Box.java, Werkzeuge.java, GenericsDemo.java

Wir wollen eine Klasse, die einen Wert aufbewahrt – egal welchen. Weil jede Klasse von Object erbt, liegt diese Lösung nahe:

ObjectBox.java
package de.drv.generics;
/** Eine Box, die jedes Objekt aufnimmt – so hat man es vor Java 5 gemacht. */
public class ObjectBox {
private Object inhalt;
public ObjectBox(Object inhalt) {
this.inhalt = inhalt;
}
public Object get() {
return inhalt;
}
public void set(Object inhalt) {
this.inhalt = inhalt;
}
}

Das funktioniert – mit zwei Haken:

ObjectBox alt = new ObjectBox("Hallo");
String text = (String) alt.get(); // 1. Ohne Cast geht es nicht
alt.set(42); // 2. Die Box nimmt alles
  1. get() liefert ein Object. Damit wir text.length() aufrufen können, müssen wir casten – also dem Compiler versichern: „Glaub mir, das ist ein String.“
  2. Ob das stimmt, prüft der Compiler nicht. Legt jemand eine Zahl in die Box, fällt das erst beim Ausführen auf:
Kaputt.java
package de.drv.generics;
public class Kaputt {
public static void main(String[] args) {
ObjectBox alt = new ObjectBox("Hallo");
alt.set(42);
String text = (String) alt.get();
System.out.println(text.length());
}
}
Terminal-Fenster
Exception in thread "main" java.lang.ClassCastException: class java.lang.Integer cannot be cast to class java.lang.String (java.lang.Integer and java.lang.String are in module java.base of loader 'bootstrap')
at de.drv.generics.Kaputt.main(Kaputt.java:8)

Der Fehler steht in Zeile 7 – gemeldet wird er in Zeile 8. In einem großen Programm liegen dazwischen womöglich tausend Zeilen und zehn Klassen.

Die Lösung: Die Klasse bekommt einen Typparameter. Er steht in spitzen Klammern hinter dem Klassennamen und wird in der Klasse wie ein Typ benutzt:

Box.java
package de.drv.generics;
/**
* Eine Box für genau einen Wert.
*
* @param <T> der Typ des Inhalts
*/
public class Box<T> {
private T inhalt;
public Box(T inhalt) {
this.inhalt = inhalt;
}
public T get() {
return inhalt;
}
public void set(T inhalt) {
this.inhalt = inhalt;
}
public boolean istLeer() {
return inhalt == null;
}
@Override
public String toString() {
return "Box[" + inhalt + "]";
}
}

T ist ein Platzhalter. Welcher Typ dafür eingesetzt wird, entscheidet erst, wer die Box benutzt:

Box<String> box = new Box<>("Hallo");
String inhalt = box.get(); // kein Cast
box.set(42); // Fehler beim Übersetzen
  • Box<String> heißt: eine Box, in der für T überall String steht. get() liefert also einen String, set nimmt nur einen String.
  • Der Cast fällt weg – der Compiler weiß, was in der Box steckt.
  • box.set(42) lässt sich gar nicht übersetzen. IntelliJ unterstreicht die Zeile sofort rot. Aus einem Fehler zur Laufzeit ist ein Fehler beim Schreiben geworden – das ist der ganze Gewinn.
  • Rechts reicht new Box<>(…): Den Typ in den leeren spitzen Klammern – dem Diamond – ergänzt der Compiler aus der linken Seite.

Für Typparameter nimmt man einzelne Großbuchstaben. Dir werden immer wieder dieselben begegnen:

Name steht für Beispiel im JDK
T Type, irgendein Typ Optional<T>
E Element einer Sammlung List<E>
K, V Key und Value Map<K, V>

Für T lassen sich nur Klassen einsetzen, keine primitiven Typen. Box<int> lässt sich nicht übersetzen. Dafür gibt es die Wrapper-Klassen, und dank Autoboxing merkt man davon beim Benutzen kaum etwas:

Box<Integer> zahl = new Box<>(42); // aus int wird Integer
int wert = zahl.get(); // aus Integer wird int

Auch eine einzelne Methode kann einen Typparameter haben. Er steht dann vor dem Rückgabetyp:

Werkzeuge.java (Ausschnitt)
/** Vertauscht zwei Elemente eines Arrays. */
public static <T> void tausche(T[] array, int i, int j) {
T merker = array[i];
array[i] = array[j];
array[j] = merker;
}
/** Packt einen Wert in eine Box. */
public static <T> Box<T> verpacke(T wert) {
return new Box<>(wert);
}

Beim Aufruf schreibt man den Typ nicht hin – der Compiler leitet ihn aus den Argumenten ab:

String[] namen = {"Anna", "Ben", "Clara"};
Werkzeuge.tausche(namen, 0, 2); // T ist String
Box<String> verpackt = Werkzeuge.verpacke("Geschenk"); // T ist String

tausche funktioniert mit jedem Array aus Objekten: String[], Integer[], Kunde[]. Nur ein int[] passt nicht – aus demselben Grund wie eben.

Manchmal muss ein Typ etwas können. Den größeren von zwei Werten findet nur, wer sie vergleichen kann – wer also Comparable implementiert:

Werkzeuge.java (Ausschnitt)
/** Der größere von zwei Werten – für jeden Typ, der sich vergleichen lässt. */
public static <T extends Comparable<T>> T max(T a, T b) {
return a.compareTo(b) >= 0 ? a : b;
}

<T extends Comparable<T>> heißt: Für T ist jeder Typ erlaubt, der sich mit seinesgleichen vergleichen lässt. Deshalb darf die Methode a.compareTo(b) aufrufen. String und Integer erfüllen das, unser Betrag aus Woche 1 auch. Eine Box nicht – Werkzeuge.max(box1, box2) lässt sich nicht übersetzen.

GenericsDemo.java
package de.drv.generics;
import java.util.Arrays;
public class GenericsDemo {
public static void main(String[] args) {
// Ohne Generics: Die Box nimmt alles – und beim Herausholen braucht es einen Cast.
ObjectBox alt = new ObjectBox("Hallo");
String text = (String) alt.get();
System.out.println(text + " hat " + text.length() + " Zeichen");
alt.set(42); // erlaubt – der Fehler zeigt sich erst beim nächsten Cast
// Mit Generics: Der Typ steht fest, der Compiler passt auf.
Box<String> box = new Box<>("Hallo");
String inhalt = box.get(); // kein Cast
System.out.println(inhalt + " hat " + inhalt.length() + " Zeichen");
System.out.println(box);
Box<Integer> zahl = new Box<>(42);
int wert = zahl.get();
System.out.println(zahl + " enthält " + wert);
// Generische Methoden
String[] namen = {"Anna", "Ben", "Clara"};
Werkzeuge.tausche(namen, 0, 2);
System.out.println(Arrays.toString(namen));
Box<String> verpackt = Werkzeuge.verpacke("Geschenk");
System.out.println(verpackt);
System.out.println(Werkzeuge.max("Birne", "Apfel"));
System.out.println(Werkzeuge.max(17, 4));
}
}
Terminal-Fenster
Hallo hat 5 Zeichen
Hallo hat 5 Zeichen
Box[Hallo]
Box[42] enthält 42
[Clara, Ben, Anna]
Box[Geschenk]
Birne
17

Arbeite im Projekt 18-generics weiter, im selben Package.

  1. Grundlage: Schreibe eine Klasse Paar<A, B> für zwei Werte, die zusammengehören – auch von verschiedenem Typ. Sie bekommt einen Konstruktor, die Getter getErstes() und getZweites() und ein toString(), das (Anna, 23) liefert. Probiere sie in einem eigenen Hauptprogramm aus, etwa mit Paar<String, Integer>.

  2. Umdrehen: Ergänze die Methode vertauscht(). Sie liefert ein neues Paar mit vertauschten Werten. Welchen Rückgabetyp hat sie?

  3. Suchen: Schreibe eine Klasse Suche mit zwei generischen Methoden:

    • enthaelt(array, gesucht): ob ein Array einen Wert enthält – verglichen mit equals
    • max(array): der größte Wert eines Arrays
  4. Für Schnelle: minMax(array) findet den kleinsten und den größten Wert in einem einzigen Durchlauf und liefert beide als Paar. Probiere es mit einem Integer[] aus. Warum geht es nicht mit einem int[]?

Lösung

vertauscht() liefert ein Paar<B, A>: Mit den Werten tauschen auch die Typen die Plätze. Aus einem Paar<String, Integer> wird ein Paar<Integer, String>.

Paar.java
package de.drv.generics;
/**
* Zwei Werte, die zusammengehören – auch von verschiedenem Typ.
*
* @param <A> der Typ des ersten Werts
* @param <B> der Typ des zweiten Werts
*/
public class Paar<A, B> {
private final A erstes;
private final B zweites;
public Paar(A erstes, B zweites) {
this.erstes = erstes;
this.zweites = zweites;
}
public A getErstes() {
return erstes;
}
public B getZweites() {
return zweites;
}
/** Ein neues Paar mit vertauschten Werten – auch die Typen tauschen die Plätze. */
public Paar<B, A> vertauscht() {
return new Paar<>(zweites, erstes);
}
@Override
public String toString() {
return "(" + erstes + ", " + zweites + ")";
}
}
Lösung

enthaelt braucht keine Typschranke: equals hat jedes Objekt. max und minMax dagegen rufen compareTo auf – dafür braucht es <T extends Comparable<T>>.

Ein int[] passt nicht zu T[], weil für T nur Klassen eingesetzt werden dürfen. Autoboxing hilft hier nicht: Es verwandelt einzelne Werte, aber kein ganzes Array.

Suche.java
package de.drv.generics;
/** Generische Methoden zum Suchen in Arrays. */
public class Suche {
/** Ob das Array den gesuchten Wert enthält – verglichen mit {@code equals}. */
public static <T> boolean enthaelt(T[] array, T gesucht) {
for (T element : array) {
if (element.equals(gesucht)) {
return true;
}
}
return false;
}
/** Der größte Wert eines Arrays mit mindestens einem Element. */
public static <T extends Comparable<T>> T max(T[] array) {
T groesstes = array[0];
for (T element : array) {
if (element.compareTo(groesstes) > 0) {
groesstes = element;
}
}
return groesstes;
}
/** Der kleinste und der größte Wert in einem Durchgang. */
public static <T extends Comparable<T>> Paar<T, T> minMax(T[] array) {
T kleinstes = array[0];
T groesstes = array[0];
for (T element : array) {
if (element.compareTo(kleinstes) < 0) {
kleinstes = element;
}
if (element.compareTo(groesstes) > 0) {
groesstes = element;
}
}
return new Paar<>(kleinstes, groesstes);
}
}
Lösung
Terminal-Fenster
(Anna, 23)
Anna ist 23
(23, Anna)
true
false
Mango
(4, 42)
UebungDemo.java
package de.drv.generics;
public class UebungDemo {
public static void main(String[] args) {
Paar<String, Integer> paar = new Paar<>("Anna", 23);
System.out.println(paar);
System.out.println(paar.getErstes() + " ist " + paar.getZweites());
Paar<Integer, String> umgekehrt = paar.vertauscht();
System.out.println(umgekehrt);
String[] obst = {"Birne", "Apfel", "Kiwi", "Mango"};
System.out.println(Suche.enthaelt(obst, "Kiwi"));
System.out.println(Suche.enthaelt(obst, "Banane"));
System.out.println(Suche.max(obst));
Integer[] zahlen = {17, 4, 42, 8};
System.out.println(Suche.minMax(zahlen));
}
}