Cosa sono i Generics e a cosa servono?

I generici in Java consentono di creare classi, interfacce e metodi che lavorano con tipi parametrizzati.

Lo scopo principale dei generici:

• Aumentare la sicurezza dei tipi: Il compilatore verifica i tipi in fase di compilazione, prevenendo ClassCastException a runtime.
• Eliminare le conversioni di tipo: Non è necessario convertire manualmente i tipi quando si estraggono elementi dalle collezioni.
• Creare codice più flessibile e riutilizzabile: È possibile scrivere algoritmi e strutture dati generici applicabili a diversi tipi di dati.

Esempio senza generici:

// Prima di Java 5
import java.util.ArrayList;
import java.util.List;

public class OldStyleList {
    public static void main(String[] args) {
        List list = new ArrayList(); // senza tipizzazione
        list.add("ciao");
        list.add(123); // può aggiungere qualsiasi oggetto

        String s = (String) list.get(0); // necessita di cast
        Integer i = (Integer) list.get(1); // necessita di cast

        // Può causare errore di cast
        // String error = (String) list.get(1); // ClassCastException
        System.out.println(s);
        System.out.println(i);
    }
}

Esempio con generici:

// Con generici
import java.util.ArrayList;
import java.util.List;

public class GenericList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(); // lista di stringhe
        list.add("ciao");
        // list.add(123); // errore di compilazione - non si può aggiungere Integer

        String s = list.get(0); // senza bisogno di cast

        // Non è possibile aggiungere un altro tipo, previene errori
        // List<Integer> intList = new ArrayList<>();
        // intList.add("mondo"); // errore di compilazione
        System.out.println(s);
    }
}

I generici sono usati anche in:

• Classi: ArrayList<E>, HashMap<K, V>
• Interfacce: List<E>, Map<K, V>
• Metodi: <T> void printArray(T[] array)
• Restrizioni di tipo: <T extends Comparable<T>> (restrizione ai tipi che implementano Comparable)

L'implementazione dei generici in Java si basa su "erasure" (eliminazione dei tipi) in fase di compilazione. Ciò significa che le informazioni sui tipi generici vengono rimosse, e a runtime la JVM opera con tipi raw. Questo garantisce compatibilità con versioni precedenti di Java, ma ha alcune limitazioni.