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

Remarquez 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 vous transmettez.

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 lorsque 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 évidence 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, démontrant ainsi que les méthodes génériques peuvent exister indépendamment des classes génériques.

Tu organiseras ton code sur deux fichiers :

ArrayUtils.java : crée une classe utilitaire contenant des méthodes génériques pour travailler avec 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 situés à 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 en pratique ! Tu recevras quatre entrées : deux mots (des chaînes de caractères) et deux nombres (des entiers).
Commence par créer 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, démontre 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

Tu recevras quatre entrées dans l'ordre suivant : premier mot, deuxième mot, premier nombre, deuxième 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 transmets : il n'est pas nécessaire 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 label et firstNumber comme value
        
        // TODO: Appeler ArrayUtils.printWithLabel avec firstNumber comme label et secondWord comme value
    }
}