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 suffit parfois qu’une seule méthode soit générique. Une méthode générique déclare son propre paramètre de type, indépendamment de tout paramètre générique défini 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[]

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

Les méthodes génériques peuvent également renvoyer 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"});  // Renvoie "a"

Tu peux 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, lorsque tu as besoin d’opérations flexibles et réutilisables sans créer de classe générique.

Défi

Facile

Construisons une boîte à outils qui met en valeur la flexibilité des méthodes génériques. Tu vas créer une classe contenant des méthodes réutilisables qui fonctionnent avec n'importe quel type, afin de montrer que les méthodes génériques peuvent exister indépendamment des classes génériques.

Tu vas répartir ton code dans deux fichiers :

ArrayUtils.java : crée une classe utilitaire contenant des méthodes génériques permettant de manipuler des tableaux. Ta classe doit comporter trois méthodes génériques statiques :
getLast - Une méthode générique qui prend un tableau de type T et renvoie le dernier élément. Si le tableau est vide, renvoie 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 renvoie 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 : mets tes méthodes génériques à l'œuvre ! Tu recevras quatre entrées : deux mots (Strings) et deux nombres (entiers).
D'abord, crée un tableau String[] contenant les deux mots. Utilise getLast pour obtenir le dernier élément et affiche : Last word: [result]

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

Enfin, illustre 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 second mot comme valeur

Tu recevras quatre entrées dans cet ordre : premier mot, second mot, premier nombre, second nombre.

Remarque que 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 tu lui transmets : inutile de les spécifier explicitement lors de l'appel des méthodes !

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
    }
}