Generics ti permettono di scrivere classi, interfacce e metodi che funzionano con un type parameter specificato dal chiamante — fornendo type safety a tempo di compilazione e eliminando i cast. Alimentano il Collections Framework e le librerie riutilizzabili.
();
list.add();
list.add();
(String) list.get();
List<String> list = <>();
list.add();
list.add();
list.get();
I generics spostano gli errori di tipo dal runtime (ClassCastException) al compile time, e rimuovono la necessità di cast manuali — rendendo il codice più sicuro e pulito.
// 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> vincola il type parameter, permettendoti di usare i membri di quel tipo in modo sicuro.
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
I wildcards aggiungono flessibilità per i parametri dei metodi che dovrebbero accettare intervalli di tipi.
// 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 implementa i generics tramite type erasure — i type parameters esistono a tempo di compilazione ma vengono rimossi a runtime, il che ha alcune limitazioni.
I generics sono essenziali per il Java moderno — forniscono type safety a tempo di compilazione (catturando gli errori di tipo presto invece che come ClassCastException a runtime), eliminano i cast verbosi e soggetti a errori, e abilitano codice riutilizzabile e type-flexible.
Sono la fondazione dell'intero Collections Framework (List<String>, Map<K,V>) e di innumerevoli librerie.
Comprendere classi/metodi generici, parametri limitati, wildcards (PECS) e la limitazione di type-erasure ti permette sia di usare le API generiche correttamente che di progettare le tue proprie astrazioni riutilizzabili e type-safe — un'abilità fondamentale per scrivere Java robusto e manutenibile.