Maîtriser les Génériques Java : Simplifier le tri et renforcer la sécurité de type

Il serait pratique d'écrire une seule méthode de tri fonctionnant pour un tableau d'Integer, de String, ou de tout type supportant l'ordre.

Les méthodes génériques et classes génériques permettent de déclarer, avec une seule déclaration, un ensemble de méthodes apparentées ou de types apparentés.

Les génériques offrent aussi la sécurité de type à la compilation : détection des types invalides avant l'exécution.

Méthodes génériques

Une seule déclaration pour des appels avec différents types d'arguments. Le compilateur gère chaque appel selon les types réels.

Règles de déclaration

• Section de paramètres de type délimitée par < et > avant le type de retour (<E>)
• Un ou plusieurs paramètres de type séparés par virgules. Identifiant = nom de type générique
• Paramètres de type utilisables comme type de retour et placeholders pour les types d'arguments réels
• Corps de méthode normal. Paramètres de type = types référence seulement (pas primitifs : int, double, char)

Exemple : affichage de tableaux de types différents

public class TestMethodeGenerique {
    // méthode générique printArray
    public static <E> void printArray(E[] inputArray) {
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }
    
    public static void main(String args[]) {
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };
        
        System.out.println("Tableau d'entiers :");
        printArray(intArray);
        
        System.out.println("\nTableau de doubles :");
        printArray(doubleArray);
        
        System.out.println("\nTableau de caractères :");
        printArray(charArray);
    }
}

Résultat :

Tableau d'entiers :
1 2 3 4 5 

Tableau de doubles :
1.1 2.2 3.3 4.4 

Tableau de caractères :
H E L L O

Paramètres de type bornés (Bounded Type Parameters)

Pour restreindre les types acceptables. Ex: méthode sur nombres → seulement Number ou sous-classes.

Syntaxe : <T extends BorneSupérieure>. extends signifie "étend" (classes) ou "implémente" (interfaces).

Exemple : maximum de trois objets Comparable

public class TestMaximum {
    // retourne le plus grand de trois objets Comparable
    public static <T extends Comparable<T>> T maximum(T x, T y, T z) {
        T max = x;
        if (y.compareTo(max) > 0) max = y;
        if (z.compareTo(max) > 0) max = z;
        return max;
    }
    
    public static void main(String args[]) {
        System.out.printf("Max de %d, %d, %d est %d\n\n", 3, 4, 5, maximum(3, 4, 5));
        System.out.printf("Max de %.1f, %.1f, %.1f est %.1f\n\n", 6.6, 8.8, 7.7, maximum(6.6, 8.8, 7.7));
        System.out.printf("Max de %s, %s, %s est %s\n", "poire", "pomme", "orange", maximum("poire", "pomme", "orange"));
    }
}

Résultat :

Max de 3, 4, 5 est 5
Max de 6.6, 8.8, 7.7 est 8.8
Max de poire, pomme, orange est poire

Classes génériques

Déclaration comme classe non-générique, mais nom suivi d'une section de paramètres de type.

Un ou plusieurs paramètres séparés par virgules. Nommées classes paramétrées ou types paramétrés.

Exemple : classe Box générique

public class Box<T> {
    private T t;
    
    public void add(T t) { this.t = t; }
    public T get() { return t; }
    
    public static void main(String[] args) {
        Box<Integer> integerBox = new Box<Integer>();
        Box<String> stringBox = new Box<String>();
        
        integerBox.add(new Integer(10));
        stringBox.add(new String("Hello World"));
        
        System.out.printf("Valeur Integer : %d\n\n", integerBox.get());
        System.out.printf("Valeur String : %s\n", stringBox.get());
    }
}

Résultat :

Valeur Integer : 10
Valeur String : Hello World

Avantages des génériques

• Réutilisabilité : une classe/méthode pour plusieurs types
• Sécurité de type : erreurs détectées à la compilation, pas à l'exécution
• Élimination des casts : pas de conversion explicite nécessaire
• Performance : pas de boxing/unboxing inutile avec types primitifs (via wrappers)

Note : Les génériques utilisent l'effacement de type (type erasure) — les informations de type générique ne sont pas disponibles à l'exécution.