Mik a generikusok és miért használjuk őket?

Question

Accepted Answer

**A generikusok** lehetővé teszik osztályok, interfészek és metódusok írását, amelyek egy **típusparaméterrel** működnek, amelyet a hívó határoz meg — **fordítási idejű típusbiztonságot** biztosítva és a vetítéseket kiküszöbölve. Lehetővé teszik a Collections Framework-öt és az újrahasználható könyvtárakat. ## A probléma, amit a generikusok megoldanak ```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 ``` A generikusok a típushibákat futási időből (`ClassCastException`) a **fordítási időre** helyezik át, és eltávolítják a manuális vetítés szükségességét — biztonságosabbá és tisztábbá teszik a kódot. ## Generikus osztályok és metódusok ```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); } ``` ## Korlátozottságú típusparaméterek ```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; } ``` `` korlátozza a típusparamétert, lehetővé téve az adott típus tagjainak biztonságos használatát. ## Wildcard-ok ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` A wildcard-ok rugalmasságot adnak azokhoz a metódusparaméterekhez, amelyeknek típusok több típusát kell elfogadniuk. ## Típustörlés (egy Java figyelmeztetés) ```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` ``` A Java **típustörlés** segítségével valósítja meg a generikusokat — a típusparaméterek fordítási időben léteznek, de futási időben eltávolításra kerülnek, ami bizonyos korlátozásokkal jár. ## Miért fontos A generikusok nélkülözhetetlenek a modern Java-ban — fordítási idejű típusbiztonságot biztosítanak (típushibákat korai időben észlelnek futási `ClassCastException` helyett), eltávolítják a szólamosságot és a hibaveszélyes vetítéseket, valamint lehetővé teszik az újrahasználható, típusban rugalmas kódot. Ezek az egész Collections Framework (`List`, `Map`) és számos könyvtár alapja. A generikus osztályok/metódusok, korlátozottságú paraméterek, wildcard-ok (PECS) és típustörlési figyelmeztetés megértése lehetővé teszi a generikus API-k helyes használatát és a saját újrahasználható, type-safe absztrakcióik megtervezését — az erős, karbantartható Java írásának alapvető készség.