Genericele te lasă să scrii clase, interfețe și metode care funcționează cu un parametru de tip specificat de apelant — oferind siguranță de tip la compilare și eliminând necesitatea casturilor. Ele alimentează Collections Framework-ul și bibliotecile reutilizabile.
();
list.add();
list.add();
(String) list.get();
List<String> list = <>();
list.add();
list.add();
list.get();
Genericele mută erorile de tip din runtime (ClassCastException) la compile time, și elimină necesitatea casturilor manuale — făcând codul mai sigur și mai curat.
// a generic class — T is a type parameter filled in by the user
public class Box<T> {
private T value;
public void set(T value) { this.value = value; }
public T get() { return value; }
}
Box<String> b = new Box<>(); // T = String
b.set("hi");
String x = b.get(); // typed, no cast
// a generic method
public static <T> T firstElement(List<T> list) {
return list.get(0);
}
// T must be Number (or a subclass) — lets you call Number methods
public static <T extends Number> double sum(List<T> list) {
double total = 0;
for (T n : list) total += n.doubleValue(); // safe — T is a Number
return total;
}
<T extends X> constrânge parametrul de tip, permițându-ți să folosești în siguranță membrii acelui tip.
List<? extends Number> nums; // "some subtype of Number" — read (producer)
List<? super Integer> sink; // "Integer or a supertype" — write (consumer)
// PECS: Producer Extends, Consumer Super
Wildcard-urile adaugă flexibilitate pentru parametrii de metodă care ar trebui să accepte o gamă de tipuri.
// generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility)
List<String> a = new ArrayList<>();
List<Integer> b = new ArrayList<>();
a.getClass() == b.getClass(); // true — both are just ArrayList at runtime
// consequence: can't do `new T()` or `instanceof List<String>`
Java implementează genericele prin type erasure — parametrii de tip există la compile time dar sunt eliminați la runtime, ceea ce are unele limitări.
Genericele sunt esențiale pentru Java modern — oferă siguranță de tip la compilare (captând erorile de tip devreme în loc să apară ca ClassCastException-uri la runtime), elimină casturile verbose și predispuse la erori, și permit cod reutilizabil și flexibil din punct de vedere al tipului.
Sunt baza întregului Collections Framework (List<String>, Map<K,V>) și a nenumăratelor biblioteci.
Înțelegerea claselor/metodelor generice, parametrilor delimitați, wildcard-urilor (PECS) și cavității type-erasure te lasă atât să folosești corect API-urile generice cât și să-ți proiectezi propriile abstracții reutilizabile și type-safe — o abilitate fundamentală pentru a scrie Java robust și ușor de întreținut.