Qu'est-ce que les types génériques ?

Les types génériques permettent de définir des classes, interfaces et méthodes en utilisant des paramètres de type. Cela augmente la flexibilité, la réutilisabilité et la sécurité de type du code, permettant de travailler avec différents types de données sans perdre la vérification statique des types.

Avantages clés:

• Sécurité de type: Le compilateur vérifie les types lors de la compilation, évitant ainsi les erreurs à l'exécution liées à des incompatibilités de types.
• Réutilisabilité: Le même code peut être utilisé avec différents types de données, ce qui réduit la duplication de code.
• Performance: Dans certains langages (par exemple, C#), les types génériques sont implémentés en tenant compte d'un type spécifique, ce qui peut améliorer la performance par rapport à l'utilisation de Object.

Exemples d'utilisation:

• Collections: Listes, dictionnaires, ensembles paramétrés par le type d'éléments.
• Méthodes: Méthodes qui fonctionnent avec n'importe quel type de données qui implémente une interface spécifique.
• Classes: Classes enveloppantes, fabriques, qui travaillent avec des types paramétrés.

Exemple en C#:

// Liste générique
List<string> noms = new List<string>();
noms.Add("Alice");
noms.Add("Bob");

// Méthode générique
public T ObtenirPremierElement<T>(List<T> liste)
{
    if (liste != null && liste.Count > 0)
    {
        return liste[0];
    }
    return default(T); // Retourne la valeur par défaut pour le type T
}

Exemple en Java:

// Liste générique
List<String> noms = new ArrayList<>();
noms.add("Alice");
noms.add("Bob");

// Méthode générique
public <T> T obtenirPremierElement(List<T> liste) {
    if (liste != null && !liste.isEmpty()) {
        return liste.get(0);
    }
    return null; // Retourne null pour les types de référence
}

Exemple en Python (type hinting):

from typing import List, TypeVar

T = TypeVar('T')

def obtenir_premier_element(donnees: List[T]) -> T | None:
    # La fonction peut travailler avec n'importe quelle liste et retourner un élément
    if donnees:
        return donnees[0]
    return None

noms: List[str] = ["Alice", "Bob"]
premier_nom = obtenir_premier_element(noms) # IDE comprend que premier_nom est str

Dans certains langages (Java), les types génériques utilisent "effacement" (type erasure), où l'information sur le type de paramètre est supprimée lors de la compilation. Cela peut entraîner certaines limitations. Dans d'autres langages (C#, Go), l'information sur le type est conservée à l'exécution.

Les types génériques sont un outil fondamental pour écrire un code propre, sûr et réutilisable.