Métodos genéricos

Parte de la sección Programación Orientada a Objetos del Journey de Java de Coddy. Lección 55 de 87.

Mientras que las clases genéricas permiten que clases enteras funcionen con distintos tipos, a veces solo necesitas que un único método sea genérico. Un método genérico declara su propio parámetro de tipo, independiente de cualquier tipo genérico declarado a nivel de clase.

El parámetro de tipo aparece antes del tipo de retorno en la firma del método:

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);    // Funciona con String[]
Utility.printArray(numbers);  // Funciona con Integer[]

Observa el <T> colocado entre los modificadores y el tipo de retorno. Esto declara T como parámetro de tipo para este método específico. El compilador infiere el tipo real a partir de los argumentos que pasas.

Los métodos genéricos también pueden devolver el tipo genérico:

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

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

Puedes usar varios parámetros de tipo cuando sea necesario:

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

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

Los métodos genéricos son especialmente útiles en las clases de utilidades, donde necesitas operaciones flexibles y reutilizables sin crear una clase genérica.

Desafío

Fácil

Vamos a crear un conjunto de herramientas que demuestre la flexibilidad de los métodos genéricos. Crearás una clase con métodos reutilizables que funcionan con cualquier tipo, para mostrar cómo los métodos genéricos pueden existir independientemente de las clases genéricas.

Organizarás tu código en dos archivos:

ArrayUtils.java: Crea una clase de utilidades que contenga métodos genéricos para trabajar con arreglos. Tu clase debe tener tres métodos genéricos estáticos:
getLast - Un método genérico que recibe un arreglo de tipo T y devuelve el último elemento. Si el arreglo está vacío, devuelve null.

swap - Un método genérico que recibe un arreglo de tipo T y dos índices enteros, y luego intercambia los elementos en esas posiciones. Este método no devuelve nada.

printWithLabel - Un método genérico con dos parámetros de tipo K y V. Recibe una etiqueta de tipo K y un valor de tipo V, y luego los imprime con el formato: [label]: [value]
Main.java: ¡Pon en práctica tus métodos genéricos! Recibirás cuatro datos de entrada: dos palabras (Strings) y dos números (enteros).
Primero, crea un arreglo String[] que contenga ambas palabras. Usa getLast para obtener el último elemento e imprime: Last word: [result]

A continuación, crea un arreglo Integer[] que contenga ambos números. Llama a swap para intercambiar los elementos en los índices 0 y 1, y luego imprime: After swap: [first], [second]

Por último, demuestra el método genérico con dos parámetros llamando a printWithLabel dos veces:
- Una vez con la primera palabra como etiqueta y el primer número como valor
- Una vez con el primer número como etiqueta y la segunda palabra como valor

Recibirás cuatro datos de entrada en este orden: primera palabra, segunda palabra, primer número, segundo número.

Observa cómo cada método declara sus propios parámetros de tipo con <T> o <K, V> antes del tipo de retorno. El compilador infiere los tipos concretos a partir de los argumentos que pasas: ¡no hace falta especificarlos explícitamente al llamar a los métodos!

Pruébalo tú mismo

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lee las entradas
        String firstWord = scanner.nextLine();
        String secondWord = scanner.nextLine();
        int firstNumber = scanner.nextInt();
        int secondNumber = scanner.nextInt();
        
        // TODO: Crea un array String[] que contenga ambas palabras
        
        // TODO: Usa ArrayUtils.getLast para obtener el último elemento
        // Imprime: "Last word: [result]"
        
        // TODO: Crea un array Integer[] que contenga ambos números
        
        // TODO: Llama a ArrayUtils.swap para intercambiar los elementos en los índices 0 y 1
        // Imprime: "After swap: [first], [second]"
        
        // TODO: Llama a ArrayUtils.printWithLabel con firstWord como etiqueta y firstNumber como valor
        
        // TODO: Llama a ArrayUtils.printWithLabel con firstNumber como etiqueta y secondWord como valor
    }
}