Was sind Generics und warum sollte man sie verwenden?

Question

Accepted Answer

**Generics** ermöglichen es dir, Klassen, Interfaces und Methoden zu schreiben, die mit einem **Typparameter** arbeiten, der vom Aufrufer angegeben wird — und bieten dabei **Compile-Zeit-Typsicherheit** und eliminieren Casts. Sie sind das Fundament des Collections Framework und wiederverwendbarer Bibliotheken. ## Das Problem, das Generics lösen ```java // ❌ before generics (or with raw types) — no type safety, requires casts List list = new ArrayList(); list.add("hello"); list.add(42); // oops — anything can go in String s = (String) list.get(1); // ClassCastException at RUNTIME! 💥 // ✅ with generics — the type is enforced at COMPILE time List list = new ArrayList<>(); list.add("hello"); list.add(42); // ❌ compile error — caught immediately String s = list.get(0); // no cast needed — known to be String ``` Generics verschieben Typfehler von der Laufzeit (`ClassCastException`) zur **Compile-Zeit** und entfernen die Notwendigkeit für manuelle Casts — was Code sicherer und sauberer macht. ## Generische Klassen und Methoden ```java // a generic class — T is a type parameter filled in by the user public class Box { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } Box b = new Box<>(); // T = String b.set("hi"); String x = b.get(); // typed, no cast // a generic method public static T firstElement(List list) { return list.get(0); } ``` ## Begrenzte Typparameter ```java // T must be Number (or a subclass) — lets you call Number methods public static double sum(List list) { double total = 0; for (T n : list) total += n.doubleValue(); // safe — T is a Number return total; } ``` `` schränkt den Typparameter ein und ermöglicht dir, die Member dieses Typs sicher zu verwenden. ## Wildcards ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` Wildcards bieten Flexibilität für Methodenparameter, die Bereiche von Typen akzeptieren sollten. ## Type Erasure (eine Java-Besonderheit) ```java // generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility) List a = new ArrayList<>(); List b = new ArrayList<>(); a.getClass() == b.getClass(); // true — both are just ArrayList at runtime // consequence: can't do `new T()` or `instanceof List` ``` Java implementiert Generics über **Type Erasure** — Typparameter existieren zur Compile-Zeit, werden aber zur Laufzeit entfernt, was einige Einschränkungen mit sich bringt. ## Warum es wichtig ist Generics sind essentiell für modernes Java — sie bieten Compile-Zeit-Typsicherheit (Typfehler werden früh erkannt, statt als Laufzeit-`ClassCastException`s zu erscheinen), eliminieren verbose und fehleranfällige Casts und ermöglichen wiederverwendbaren, typflexiblen Code. Sie sind das Fundament des gesamten Collections Framework (`List`, `Map`) und unzähliger Bibliotheken. Das Verständnis von generischen Klassen/Methoden, begrenzten Parametern, Wildcards (PECS) und der Type-Erasure-Besonderheit ermöglicht es dir, sowohl generische APIs korrekt zu nutzen als auch deine eigenen wiederverwendbaren, typsicheren Abstraktionen zu entwerfen — eine Kernfähigkeit zum Schreiben von robustem, wartbarem Java.