Qu'est-ce qu'un joker en Java?

Le caractère générique (?) en Java est utilisé dans les génériques pour représenter un type inconnu. Il permet de travailler avec des collections contenant des éléments de types compatibles différents, sans être strictement lié à un type spécifique.

Les scénarios principaux d'utilisation :

? (générique avec borne supérieure) : Indique tout type qui est un sous-type ou qui implémente l'interface spécifiée. Utilisé pour lire des données d'une collection. Exemple : List<? extends Number> peut contenir List<Integer>, List<Double>, .getList<Long>.

// Lecture d'une collection avec borne supérieure
public void processNumbers(List<? extends Number> numbers) {
    for (Number n : numbers) {
        System.out.println(n);
    }
    // numbers.add(new Integer(10)); // Erreur de compilation - impossible d'ajouter des éléments
}

? super (générique avec borne inférieure) : Indique tout type qui est un supertype de la classe/interface spécifiée ou cette classe/interface elle-même. Utilisé pour écrire dans une collection (principe PECS : Producteur Extends, Consommateur Super). Exemple : List<? super Integer> peut contenir List<Integer>, List<Number>, List<Object>.
```
// Écriture dans une collection avec borne inférieure
public void addIntegers(List<? super Integer> list) {
    list.add(1);
    list.add(new Integer(2));
    // Object o = list.get(0); // Retourne Object, car le type exact est inconnu
}
```

? (générique sans borne) : Indique tout type. Équivalent à ? extends Object. Utilisé lorsque le type exact des éléments de la collection n'importe pas, par exemple pour vérifier la taille ou nettoyer.

// Travailler avec une collection de n'importe quel type
public void printList(List<?> list) {
    for (Object obj : list) {
        System.out.println(obj);
    }
    // list.add("hello"); // Erreur de compilation - impossible d'ajouter des éléments (sauf null)
}

Les génériques avec des caractères génériques augmentent la flexibilité du code, permettant aux méthodes de travailler avec une gamme plus large de types de collections, tout en maintenant la sécurité de type. Avec leur aide, il est possible d'éviter la duplication de code pour des méthodes effectuant des opérations similaires sur des collections de types différents mais compatibles.