Cos'è un wildcard in Java?

Il carattere jolly (?) in Java viene utilizzato nei generici per rappresentare un tipo sconosciuto. Permette di lavorare con collezioni contenenti elementi di tipi compatibili diversi, senza essere strettamente legato a un tipo specifico.

Gli scenari principali di utilizzo:

? (Wildcard con limite superiore): Indica qualsiasi tipo che sia un sottotipo o che implementi l'interfaccia specificata. Viene usato per leggere dati da una collezione. Esempio: List<? extends Number> può contenere List<Integer>, List<Double>, .getList<Long>.

// Lettura da una collezione con limite superiore
public void processNumbers(List<? extends Number> numbers) {
    for (Number n : numbers) {
        System.out.println(n);
    }
    // numbers.add(new Integer(10)); // Errore di compilazione - impossibile aggiungere elementi
}

? (Wildcard con limite inferiore): Indica qualsiasi tipo che sia un supertipo della classe/interfaccia specificata o la stessa classe/interfaccia. Viene usato per scrivere in una collezione (principio PECS: Producer Extends, Consumer Super). Esempio: List<? super Integer> può contenere List<Integer>, List<Number>, List<Object>.
```
// Scrittura in una collezione con limite inferiore
public void addIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(new Integer(2));
    // Object o = list.get(0); // Restituisce Object, poiché il tipo esatto è sconosciuto
}
```

? (Wildcard senza limite): Indica qualsiasi tipo. È equivalente a ? extends Object. Viene usato quando il tipo effettivo degli elementi della collezione non è importante, ad esempio per verificare la dimensione o svuotare.

// Lavorare con una collezione di qualsiasi tipo
public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
    // list.add("hello"); // Errore di compilazione - impossibile aggiungere elementi (tranne null)
}

I wildcards aumentano la flessibilità del codice, consentendo ai metodi di lavorare con una gamma più ampia di tipi di collezioni, mantenendo la sicurezza dei tipi. Con il loro aiuto, è possibile evitare la duplicazione del codice per metodi che eseguono operazioni simili su collezioni di tipi diversi ma compatibili.