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.
Was du am Ende kannst
Abschnitt betitelt „Was du am Ende kannst“- erklären, welches Problem Generics lösen
- eine generische Klasse schreiben und benutzen
- eine generische Methode schreiben
- einen Typparameter mit
extendseinschränken
Demo-Code: 18-generics
⤓ demo-generics.zip herunterladenDer 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
Das Problem: eine Box für alles
Abschnitt betitelt „Das Problem: eine Box für alles“Wir wollen eine Klasse, die einen Wert aufbewahrt – egal welchen. Weil jede
Klasse von Object erbt, liegt diese Lösung nahe:
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 nichtalt.set(42); // 2. Die Box nimmt allesget()liefert einObject. Damit wirtext.length()aufrufen können, müssen wir casten – also dem Compiler versichern: „Glaub mir, das ist ein String.“- Ob das stimmt, prüft der Compiler nicht. Legt jemand eine Zahl in die Box, fällt das erst beim Ausführen auf:
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()); }
}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 generische Klasse Box<T>
Abschnitt betitelt „Die generische Klasse Box<T>“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:
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 Castbox.set(42); // Fehler beim ÜbersetzenBox<String>heißt: eine Box, in der fürTüberallStringsteht.get()liefert also einenString,setnimmt nur einenString.- 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> |
Nur Objekte
Abschnitt betitelt „Nur Objekte“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 Integerint wert = zahl.get(); // aus Integer wird intGenerische Methoden
Abschnitt betitelt „Generische Methoden“Auch eine einzelne Methode kann einen Typparameter haben. Er steht dann vor dem Rückgabetyp:
/** 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 StringBox<String> verpackt = Werkzeuge.verpacke("Geschenk"); // T ist Stringtausche funktioniert mit jedem Array aus Objekten: String[], Integer[],
Kunde[]. Nur ein int[] passt nicht – aus demselben Grund wie eben.
Typschranken: extends
Abschnitt betitelt „Typschranken: extends“Manchmal muss ein Typ etwas können. Den größeren von zwei Werten findet nur,
wer sie vergleichen kann – wer also
Comparable implementiert:
/** 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.
Alles zusammen
Abschnitt betitelt „Alles zusammen“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)); }
}Hallo hat 5 ZeichenHallo hat 5 ZeichenBox[Hallo]Box[42] enthält 42[Clara, Ben, Anna]Box[Geschenk]Birne17Übung: Ein Paar
Abschnitt betitelt „Übung: Ein Paar“Arbeite im Projekt 18-generics weiter, im selben Package.
-
Grundlage: Schreibe eine Klasse
Paar<A, B>für zwei Werte, die zusammengehören – auch von verschiedenem Typ. Sie bekommt einen Konstruktor, die GettergetErstes()undgetZweites()und eintoString(), das(Anna, 23)liefert. Probiere sie in einem eigenen Hauptprogramm aus, etwa mitPaar<String, Integer>. -
Umdrehen: Ergänze die Methode
vertauscht(). Sie liefert ein neues Paar mit vertauschten Werten. Welchen Rückgabetyp hat sie? -
Suchen: Schreibe eine Klasse
Suchemit zwei generischen Methoden:enthaelt(array, gesucht): ob ein Array einen Wert enthält – verglichen mitequalsmax(array): der größte Wert eines Arrays
-
Für Schnelle:
minMax(array)findet den kleinsten und den größten Wert in einem einzigen Durchlauf und liefert beide alsPaar. Probiere es mit einemInteger[]aus. Warum geht es nicht mit einemint[]?
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>.
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.
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
(Anna, 23)Anna ist 23(23, Anna)truefalseMango(4, 42)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)); }
}