Quelles fonctionnalités offrent les Génériques en…

Les génériques en Java améliorent la sécurité des types du code, en évitant les erreurs d’exécution liées à la conversion de types. Les principales fonctionnalités :

Vérification des types à la compilation : Le compilateur vérifie l’utilisation correcte des types spécifiés dans les génériques, permettant de détecter les erreurs avant l’exécution.

// Sans génériques - possible ClassCastException
List list = new ArrayList();
list.add("chaîne");
list.add(123); // Ajout d’un Integer
String s = (String) list.get(1); // Erreur à l’exécution

// Avec génériques - erreur de compilation
List<String> stringList = new ArrayList<>();
stringList.add("chaîne");
// stringList.add(123); // Erreur de compilation
String str = stringList.get(0); // Récupération sécurisée

Suppression des conversions de types (type casting) : Les génériques évitent la nécessité de faire des conversions explicites lors de la récupération d’éléments dans des collections ou l’utilisation de classes paramétrées.

// Sans génériques
List list = new ArrayList();
list.add("Bonjour");
String s = (String) list.get(0); // Conversion explicite

// Avec génériques
List<String> stringList = new ArrayList<>();
stringList.add("Bonjour");
String str = stringList.get(0); // Pas besoin de conversion

Implémentation de code générique (Méthodes génériques, Classes génériques, Interfaces génériques) : Permettent de créer des algorithmes et des structures de données génériques qui fonctionnent avec différents types sans dupliquer le code.

// Méthode générique pour imprimer un tableau
public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.print(element + " ");
    }
    System.out.println();
}

// Classe générique - paire de valeurs
class Pair<K, V> {
    private K key;
    private V value;

    public Pair(K key, V value) {
        this.key = key;
        this.value = value;
    }

    public K getKey() { return key; }
    public V getValue() { return value; }
}

Support des Wildcards : Permettent de définir des restrictions flexibles sur les types dans les types paramétrés.

? (Wildcard non borné) : Tout type.
? extends T (Wildcard avec limite supérieure) : Le type doit être T ou un sous-type de T.
? super T (Wildcard avec limite inférieure) : Le type doit être T ou un supertype de T.

// Méthode acceptant une liste de n’importe quel type
public static void processList(List<?> list) {
    // ...
}

// Méthode acceptant une liste de nombres ou de leurs sous-types
public static void processNumbers(List<? extends Number> list) {
    // ...
}

// Méthode acceptant une liste de chaînes ou de leurs super-types
public static void addStrings(List<? super String> list) {
    list.add("nouvelle chaîne");
}

Utilisation dans le framework Collections : Toutes les classes principales de collections (List, Set, Map, etc.) sont paramétrées, ce qui rend le travail avec les collections sûr en termes de types et pratique.

Les génériques sont un élément clé de Java moderne, augmentant la fiabilité et la lisibilité du code.

Quelles fonctionnalités offrent les Génériques en Java?