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 diferentes 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, independientemente de cualquier genérico 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 un 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 múltiples 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 particularmente útiles en las clases de utilidad donde se necesitan operaciones flexibles y reutilizables sin necesidad de crear una clase genérica.

Desafío

Fácil

Construyamos un kit de herramientas de utilidad que muestre la flexibilidad de los métodos genéricos. Crearás una clase con métodos reutilizables que funcionen con cualquier tipo, demostrando 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 utilidad 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 toma 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 toma un arreglo de tipo T y dos índices enteros, 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. Toma una etiqueta de tipo K y un valor de tipo V, luego los imprime en el formato: [label]: [value]
Main.java: ¡Pon a trabajar tus métodos genéricos! Recibirás cuatro entradas: 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, luego imprime: After swap: [first], [second]

Finalmente, demuestra el método genérico de 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 entradas en orden: primera palabra, segunda palabra, primer número, segundo número.

Observa cómo cada método declara su(s) propio(s) parámetro(s) de tipo con <T> o <K, V> antes del tipo de retorno. El compilador infiere los tipos reales a partir de los argumentos que pasas; ¡no es necesario especificarlos explícitamente al llamar a los métodos!

Hoja de referencia

Un método genérico declara su propio parámetro de tipo, independientemente de cualquier genérico a nivel de clase. El parámetro de tipo aparece antes del tipo de retorno en la firma del método.

Sintaxis básica de un método genérico:

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

El <T> se coloca entre los modificadores y el tipo de retorno. El compilador infiere el tipo real a partir de los argumentos que pases.

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

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

Se pueden utilizar múltiples parámetros de tipo:

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

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

Los métodos genéricos son útiles en clases de utilidad para operaciones flexibles y reutilizables sin necesidad de crear una clase genérica.

Pruébalo tú mismo

import java.util.Scanner;

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