Qu'est-ce que la généralisation (Génériques) en…

Les génériques sont un mécanisme dans les langages de programmation qui permet de créer des composants (classes, interfaces, méthodes/fonctions) qui fonctionnent avec différents types de données, sans perdre la sécurité de type et sans recourir à des conversions de type (casting).

Les principaux objectifs de l'utilisation des génériques :

Amélioration de la sécurité de type : Le compilateur vérifie les types lors de la compilation, détectant les erreurs avant l'exécution du programme.
Amélioration de la lisibilité du code : Il est clair avec quels types de données un composant travaille.
Réutilisation du code : On peut créer un seul composant qui fonctionne avec différents types, au lieu d'écrire plusieurs versions.
Réduction des conversions de type : Élimine le besoin de conversions explicites, rendant le code plus propre et moins sujet aux erreurs ClassCastException (dans les langages où cela s'applique, par exemple Java).

Exemples d'utilisation des génériques :

Collections : Listes (List), ensembles (Set), cartes (Map) peuvent stocker des éléments d'un type spécifique, garantissant que d'autres types ne soient pas insérés.
Méthodes/fonctions : Une méthode peut travailler avec des paramètres ou retourner une valeur de type universel.
Classes/interfaces : On peut créer des structures de données universelles ou des modèles de comportement.

Exemple en Java :

// Classe générique Pair
public class Pair<T, U> {
    private T first;
    private U second;

    public Pair(T first, U second) {
        this.first = first;
        this.second = second;
    }

    public T getFirst() {
        return first;
    }

    public U getSecond() {
        return second;
    }
}

// Utilisation
Pair<String, Integer> pair = new Pair<>("Hello", 123);
String str = pair.getFirst(); // Pas besoin de casting
int num = pair.getSecond();   // Pas besoin de casting

// Pair<String, Integer> wrongPair = new Pair<>(123, "Hello"); // Erreur de compilation : types incompatibles

Exemple en C# :

// Classe générique Pair
public class Pair<T, U>
{
    public T First { get; set; }
    public U Second { get; set; }

    public Pair(T first, U second)
    {
        First = first;
        Second = second;
    }
}

// Utilisation
var pair = new Pair<string, int>("Hello", 123);
string str = pair.First; // Pas besoin de casting
int num = pair.Second;   // Pas besoin de casting

// var wrongPair = new Pair<string, int>(123, "Hello"); // Erreur de compilation : types incompatibles

Exemple en TypeScript :

// Fonction générique pour obtenir le premier élément d'un tableau
function getFirstElement<T>(arr: T[]): T | undefined {
    if (arr.length > 0) {
        return arr[0];
    }
    return undefined;
}

// Utilisation
let numbers: number[] = [1, 2, 3];
let firstNumber = getFirstElement(numbers); // firstNumber a le type number

let words: string[] = ["a", "b", "c"];
let firstWord = getFirstElement(words);   // firstWord a le type string

// let mixedArray: (number | string)[] = [1, "a", 2];
// let firstMixed = getFirstElement(mixedArray); // firstMixed a le type number | string

Ainsi, les génériques sont un outil puissant pour créer un code flexible, sûr en types et réutilisable.

Qu'est-ce que la généralisation (Génériques) en programmation?