Guida Java interattiva: Generics

Q: Perché usare i generics invece di Object?

Usare Object fa perdere tutte le informazioni sul tipo: il compilatore non può impedirti di inserire la cosa sbagliata, e devi fare il cast di ogni valore che estrai (rischiando una ClassCastException a runtime). I generics spostano quel controllo in fase di compilazione. List semplicemente non accetta un Integer, e get() restituisce già una String: niente cast, niente sorprese a runtime.

Perché esistono i generics

Un tipo generico ti permette di scrivere il codice una volta e riutilizzarlo per molti tipi senza rinunciare alla sicurezza sui tipi. Invece di scrivere un IntBox, uno StringBox e uno UserBox separati, scrivi un solo Box<T>, dove T è un segnaposto che chi usa la classe riempie.

Hai già usato i generics ogni volta che hai scritto ArrayList<String> o una HashMap come HashMap<String, Integer>. La parte <...> è un argomento di tipo. Questa pagina mostra come scrivere i tuoi.

L'alternativa, memorizzare tutto come Object, butta via le informazioni sul tipo e ti costringe a cast brutti e soggetti a errori:

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);                       // niente impedisce questo errore

        String first = (String) raw.get(0); // ogni lettura richiede un cast
        String oops = (String) raw.get(1);  // compila, poi va in crash a runtime
        System.out.println(first + " " + oops);
    }
}

Quel cast nell'ultima riga lancia una ClassCastException a runtime: proprio il tipo di eccezione che i generics sono pensati per rendere impossibile.

Una classe generica

Dichiara un parametro di tipo tra parentesi angolari dopo il nome della classe. Per convenzione è una sola lettera maiuscola: T per "type", E per "element", K/V per chiave/valore.

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();     // niente cast: il compilatore sa che è una String
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // non compila: Box<String> accetta solo String
    }
}

Dentro Box, ogni T diventa il tipo fornito da chi usa la classe. Box<String> è una scatola che contiene e restituisce solo String. Il compilatore rifiuta name.set(99) prima ancora che il programma venga eseguito.

Il <> vuoto a destra (il diamond operator) permette al compilatore di dedurre l'argomento di tipo dal lato sinistro, così non ripeti <String> due volte.

Metodi generici

Un singolo metodo può avere un proprio parametro di tipo, indipendente dalla classe. Metti il parametro <T> prima del tipo di ritorno:

import java.util.List;

public class Main {

    // <T> dichiara il parametro di tipo; T è il tipo degli elementi
    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 dedotto come String
        Integer n = firstOrNull(nums);   // T dedotto come Integer
        System.out.println(w + " " + n);
    }
}

Non passi mai T in modo esplicito: il compilatore lo deduce dall'argomento. I metodi generici sono il motivo per cui utility come Collections.sort o List.of restano type-safe con qualsiasi tipo di elemento.

Parametri di tipo vincolati

A volte un tipo generico ha senso solo per alcuni tipi. extends vincola il parametro, così puoi chiamare i metodi del limite. Qui T extends Number significa che T è Number o una sua sottoclasse (Integer, Double, ...), quindi doubleValue() è disponibile:

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();   // lecito perché T è almeno un Number
        }
        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
    }
}

Nota che qui extends significa "è un sottotipo di", e funziona sia con le classi sia con le interfacce: <T extends Comparable<T>> è molto comune quando devi confrontare degli elementi.

Wildcard: ? extends e ? super

Una trappola sottile: List<Integer> non è una List<Number>, anche se Integer è un Number. I generics sono invarianti. Le wildcard allentano questo vincolo quando devi solo leggere o solo scrivere.

Usa ? extends T per un produttore da cui leggi, e ? super T per un consumatore in cui scrivi (la regola "PECS": Producer Extends, Consumer Super):

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

public class Main {

    // legge dei Number: accetta List<Integer>, List<Double>, ecc.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // scrive degli Integer: accetta 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));      // funziona grazie a ? extends

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

Una lista ? extends Number ti permette di leggere gli elementi come Number ma non di aggiungerne (il compilatore non può sapere il tipo esatto degli elementi). Una lista ? super Integer ti permette di aggiungere Integer, ma le letture restituiscono Object. Scegli la wildcard in base a come scorrono i dati.

La type erasure e i suoi limiti

I generics sono una funzionalità della fase di compilazione. Dopo la compilazione il parametro di tipo viene cancellato: a runtime Box<String> e Box<Integer> sono entrambi solo Box. Questo mantiene i generics compatibili con il codice vecchio, ma impone limiti concreti.

// Nessuno di questi compila: il parametro di tipo non esiste a runtime:
T value = new T();          // non si può istanziare un parametro di tipo
T[] array = new T[10];      // non si può creare un array generico
if (list instanceof List<String>) { } // non si può verificare l'argomento di tipo

Dato che il tipo sparisce a runtime, non puoi chiedere "cos'era T?" tramite reflection, e non puoi fare l'overloading di metodi che differiscono solo per l'argomento generico (foo(List<String>) e foo(List<Integer>) diventano la stessa firma dopo la cancellazione). Quando ti serve davvero il tipo a runtime, passa un token Class<T> come parametro del costruttore o del metodo.

Prossimo passo: le lambda expression

Hai visto che un metodo generico riceve un tipo come parametro. Il passo successivo è trattare un comportamento come parametro. Le lambda expression ti permettono di passare un pezzo di codice, una funzione, a un metodo: è proprio così che ordinerai, filtrerai e trasformerai in modo type-safe le collezioni generiche che hai appena imparato a usare.

Domande frequenti

Cosa sono i generics in Java?

I generics ti permettono di scrivere una classe o un metodo che funziona con un tipo specificato in seguito, invece di legarlo a un solo tipo concreto. Dichiari un parametro di tipo tra parentesi angolari, class Box<T>, e chi usa il codice indica il tipo reale, Box<String>. Il compilatore poi impone quel tipo ovunque, così scopri le incongruenze in fase di compilazione ed eviti i cast manuali.

Perché usare i generics invece di Object?

Usare Object fa perdere tutte le informazioni sul tipo: il compilatore non può impedirti di inserire la cosa sbagliata, e devi fare il cast di ogni valore che estrai (rischiando una ClassCastException a runtime). I generics spostano quel controllo in fase di compilazione. List<String> semplicemente non accetta un Integer, e get() restituisce già una String: niente cast, niente sorprese a runtime.

Cos'è la type erasure nei generics di Java?

La type erasure significa che le informazioni sui tipi generici esistono solo in fase di compilazione. Dopo la compilazione, List<String> e List<Integer> sono entrambe solo List a runtime: il parametro di tipo viene cancellato. Ecco perché non puoi scrivere new T[10], usare list instanceof List<String> o leggere un parametro di tipo tramite reflection. I generics ti danno sicurezza in fase di compilazione, non informazioni sui tipi a runtime.

Concetti correlati