Java Generics: typsichere Klassen und Methoden

Warum es Generics gibt

Ein generischer Typ erlaubt dir, Code einmal zu schreiben und für viele Typen wiederzuverwenden, ohne auf Typsicherheit zu verzichten. Statt eine separate IntBox, StringBox und UserBox zu schreiben, schreibst du eine einzige Box<T>, bei der T ein Platzhalter ist, den der Aufrufer ausfüllt.

Du hast Generics bereits jedes Mal verwendet, wenn du ArrayList<String> oder HashMap<String, Integer> geschrieben hast. Der <...>-Teil ist ein Typargument. Diese Seite zeigt, wie du eigene schreibst.

Die Alternative - alles als Object zu speichern - wirft die Typinformation weg und erzwingt hässliche, fehleranfällige Casts:

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

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("hello");
        raw.add(42);                       // nichts verhindert diesen Fehler

        String first = (String) raw.get(0); // jeder Lesezugriff braucht einen Cast
        String oops = (String) raw.get(1);  // kompiliert, stürzt dann zur Laufzeit ab
        System.out.println(first + " " + oops);
    }
}

Der Cast in der letzten Zeile wirft zur Laufzeit eine ClassCastException - genau die Art von Fehler, die Generics unmöglich machen sollen.

Eine generische Klasse

Deklariere einen Typparameter in spitzen Klammern nach dem Klassennamen. Per Konvention ist es ein einzelner Großbuchstabe: T für „type" (Typ), E für „element", K/V für Schlüssel/Wert.

class Box<T> {
    private T value;

    Box(T value) { this.value = value; }

    T get() { return value; }
    void set(T value) { this.value = value; }
}

public class Main {
    public static void main(String[] args) {
        Box<String> name = new Box<>("Coddy");
        Box<Integer> count = new Box<>(3);

        String s = name.get();     // kein Cast - der Compiler weiß, dass es ein String ist
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // kompiliert nicht - Box<String> akzeptiert nur Strings
    }
}

Innerhalb von Box wird jedes T zu dem, was der Aufrufer angegeben hat. Box<String> ist eine Box, die nur String aufnimmt und zurückgibt. Der Compiler lehnt name.set(99) ab, bevor das Programm überhaupt läuft.

Die leeren <> auf der rechten Seite (der Diamond-Operator) lassen den Compiler das Typargument von der linken Seite ableiten, sodass du <String> nicht zweimal wiederholen musst.

Generische Methoden

Eine einzelne Methode kann ihren eigenen Typparameter haben, unabhängig von der Klasse. Setze den Parameter <T> vor den Rückgabetyp:

import java.util.List;

public class Main {

    // <T> deklariert den Typparameter; T ist der Elementtyp
    static <T> T firstOrNull(List<T> items) {
        return items.isEmpty() ? null : items.get(0);
    }

    public static void main(String[] args) {
        List<String> words = List.of("alpha", "beta");
        List<Integer> nums = List.of(10, 20, 30);

        String w = firstOrNull(words);   // T wird als String abgeleitet
        Integer n = firstOrNull(nums);   // T wird als Integer abgeleitet
        System.out.println(w + " " + n);
    }
}

Du übergibst T nie explizit - der Compiler leitet es aus dem Argument ab. Generische Methoden sind der Grund, warum Werkzeuge wie Collections.sort oder List.of über jeden Elementtyp hinweg typsicher bleiben.

Beschränkte Typparameter

Manchmal ergibt ein generischer Typ nur für manche Typen Sinn. extends schränkt den Parameter ein, sodass du die Methoden der Schranke aufrufen kannst. Hier bedeutet T extends Number, dass T ein Number oder eine beliebige Unterklasse (Integer, Double, ...) ist, sodass doubleValue() verfügbar ist:

import java.util.List;

public class Main {

    static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue();   // erlaubt, weil T mindestens ein Number ist
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(List.of(1, 2, 3)));        // Integers
        System.out.println(sum(List.of(1.5, 2.5)));       // Doubles
    }
}

Beachte, dass extends hier „ist ein Untertyp von" bedeutet und sowohl für Klassen als auch für Interfaces funktioniert - <T extends Comparable<T>> ist äußerst verbreitet, wenn du Elemente vergleichen musst.

Wildcards: ? extends und ? super

Ein subtiler Fallstrick: List<Integer> ist keine List<Number>, obwohl Integer ein Number ist. Generics sind invariant. Wildcards lockern dies, wenn du nur lesen oder nur schreiben musst.

Verwende ? extends T für einen Producer, aus dem du liest, und ? super T für einen Consumer, in den du schreibst (die „PECS"-Regel - Producer Extends, Consumer Super):

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

public class Main {

    // liest Numbers heraus - akzeptiert List<Integer>, List<Double>, usw.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // schreibt Integers hinein - akzeptiert List<Integer>, List<Number>, List<Object>
    static void addInts(List<? super Integer> dest) {
        dest.add(1);
        dest.add(2);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        System.out.println(total(ints));      // funktioniert dank ? extends

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // funktioniert dank ? super
        System.out.println(bucket);
    }
}

Eine ? extends Number-Liste lässt dich Elemente als Number lesen, aber nichts hinzufügen (der Compiler kann den genauen Elementtyp nicht kennen). Eine ? super Integer-Liste lässt dich Integer hinzufügen, aber Lesezugriffe kommen als Object zurück. Wähle die Wildcard, die zum Datenfluss passt.

Type Erasure und ihre Grenzen

Generics sind ein Feature der Kompilierzeit. Nach dem Kompilieren wird der Typparameter gelöscht - zur Laufzeit sind Box<String> und Box<Integer> beide nur eine Box. Das hält Generics abwärtskompatibel mit altem Code, bringt aber echte Einschränkungen mit sich.

// Keines davon kompiliert - der Typparameter existiert zur Laufzeit nicht:
T value = new T();          // ein Typparameter kann nicht instanziiert werden
T[] array = new T[10];      // ein generisches Array kann nicht erstellt werden
if (list instanceof List<String>) { } // das Typargument kann nicht geprüft werden

Da der Typ zur Laufzeit verschwunden ist, kannst du nicht per Reflection fragen „was war T?", und du kannst keine Methoden überladen, die sich nur durch ihr generisches Argument unterscheiden (foo(List<String>) und foo(List<Integer>) werden auf dieselbe Signatur reduziert). Wenn du den Typ wirklich zur Laufzeit brauchst, übergib ein Class<T>-Token als Konstruktor- oder Methodenparameter.

Als Nächstes: Lambda-Ausdrücke

Du hast gesehen, dass eine generische Methode einen Typ als Parameter entgegennimmt. Der nächste Schritt ist, Verhalten als Parameter zu behandeln. Lambda-Ausdrücke erlauben dir, ein Stück Code - eine Funktion - an eine Methode zu übergeben, und genau so wirst du die generischen Collections sortieren, filtern und transformieren, die du gerade typsicher zu schreiben gelernt hast.