Méthodes génériques

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 55 sur 87.

Alors que les classes génériques permettent à des classes entières de fonctionner avec différents types, il arrive parfois que seule une méthode doive être générique. Une méthode générique déclare son propre paramètre de type, indépendamment de tout générique au niveau de la classe.

Le paramètre de type apparaît avant le type de retour dans la signature de la méthode :

public class Utility {
    public static <T> void printArray(T[] array) {
        for (T element : array) {
            System.out.println(element);
        }
    }
}

String[] names = {"Alice", "Bob"};
Integer[] numbers = {1, 2, 3};

Utility.printArray(names);    // Fonctionne avec String[]
Utility.printArray(numbers);  // Fonctionne avec Integer[]

Remarquez le <T> placé entre les modificateurs et le type de retour. Cela déclare T comme un paramètre de type pour cette méthode spécifique. Le compilateur déduit le type réel à partir des arguments que vous passez.

Les méthodes génériques peuvent également retourner le type générique :

public static <T> T getFirst(T[] array) {
    if (array.length > 0) {
        return array[0];
    }
    return null;
}

String first = getFirst(new String[]{"a", "b"});  // Retourne "a"

Vous pouvez utiliser plusieurs paramètres de type si nécessaire :

public static <K, V> void printPair(K key, V value) {
    System.out.println(key + ": " + value);
}

printPair("Age", 25);        // String et Integer
printPair(1, "First");       // Integer et String

Les méthodes génériques sont particulièrement utiles dans les classes utilitaires où vous avez besoin d'opérations flexibles et réutilisables sans créer de classe générique.

Défi

Facile

Construisons une boîte à outils utilitaire qui met en valeur la flexibilité des méthodes génériques. Vous allez créer une classe avec des méthodes réutilisables qui fonctionnent avec n'importe quel type, démontrant ainsi comment les méthodes génériques peuvent exister indépendamment des classes génériques.

Vous organiserez votre code sur deux fichiers :

ArrayUtils.java : Créez une classe utilitaire contenant des méthodes génériques pour travailler avec des tableaux. Votre classe doit avoir trois méthodes génériques statiques :
getLast - Une méthode générique qui prend un tableau de type T et retourne le dernier élément. Si le tableau est vide, retournez null.

swap - Une méthode générique qui prend un tableau de type T et deux indices entiers, puis échange les éléments à ces positions. Cette méthode ne retourne rien.

printWithLabel - Une méthode générique avec deux paramètres de type K et V. Elle prend une étiquette de type K et une valeur de type V, puis les affiche au format : [label]: [value]
Main.java : Mettez vos méthodes génériques au travail ! Vous recevrez quatre entrées : deux mots (Strings) et deux nombres (entiers).
Tout d'abord, créez un tableau String[] contenant les deux mots. Utilisez getLast pour obtenir le dernier élément et affichez : Last word: [result]

Ensuite, créez un tableau Integer[] contenant les deux nombres. Appelez swap pour échanger les éléments aux indices 0 et 1, puis affichez : After swap: [first], [second]

Enfin, démontrez la méthode générique à deux paramètres en appelant printWithLabel deux fois :
- Une fois avec le premier mot comme étiquette et le premier nombre comme valeur
- Une fois avec le premier nombre comme étiquette et le deuxième mot comme valeur

Vous recevrez quatre entrées dans l'ordre : premier mot, deuxième mot, premier nombre, deuxième nombre.

Remarquez comment chaque méthode déclare son ou ses propres paramètres de type avec <T> ou <K, V> avant le type de retour. Le compilateur déduit les types réels à partir des arguments que vous passez — pas besoin de les spécifier explicitement lors de l'appel des méthodes !

Aide-mémoire

Une méthode générique déclare son propre paramètre de type, indépendamment de tout générique au niveau de la classe. Le paramètre de type apparaît avant le type de retour dans la signature de la méthode.

Syntaxe de base d'une méthode générique :

public static <T> void printArray(T[] array) {
    for (T element : array) {
        System.out.println(element);
    }
}

Le <T> est placé entre les modificateurs et le type de retour. Le compilateur déduit le type réel à partir des arguments que vous passez.

Les méthodes génériques peuvent retourner le type générique :

public static <T> T getFirst(T[] array) {
    if (array.length > 0) {
        return array[0];
    }
    return null;
}

Plusieurs paramètres de type peuvent être utilisés :

public static <K, V> void printPair(K key, V value) {
    System.out.println(key + ": " + value);
}

printPair("Age", 25);        // String et Integer
printPair(1, "First");       // Integer et String

Les méthodes génériques sont utiles dans les classes utilitaires pour des opérations flexibles et réutilisables sans créer de classe générique.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les entrées
        String firstWord = scanner.nextLine();
        String secondWord = scanner.nextLine();
        int firstNumber = scanner.nextInt();
        int secondNumber = scanner.nextInt();
        
        // TODO: Créer un tableau String[] contenant les deux mots
        
        // TODO: Utiliser ArrayUtils.getLast pour obtenir le dernier élément
        // Afficher : "Last word: [result]"
        
        // TODO: Créer un tableau Integer[] contenant les deux nombres
        
        // TODO: Appeler ArrayUtils.swap pour échanger les éléments aux indices 0 et 1
        // Afficher : "After swap: [first], [second]"
        
        // TODO: Appeler ArrayUtils.printWithLabel avec firstWord comme étiquette et firstNumber comme valeur
        
        // TODO: Appeler ArrayUtils.printWithLabel avec firstNumber comme étiquette et secondWord comme valeur
    }
}