Dominando Genéricos en Java: Simplifica Ordenación y Mejora Seguridad de Tipos

Sería útil escribir un único método de ordenación que funcione para arrays de Integer, String o cualquier tipo que soporte ordenación.

Los Genéricos (Generics) en Java permiten declarar, con una sola declaración de método o clase, un conjunto de métodos o tipos relacionados. Además, proporcionan seguridad de tipos en tiempo de compilación, detectando tipos inválidos antes de ejecutar.

Métodos Genéricos

Un único método genérico puede llamarse con argumentos de diferentes tipos. El compilador maneja cada llamada según los tipos de argumentos reales.

Reglas para Definir Métodos Genéricos

1. Sección de parámetros de tipo delimitada por < y > antes del tipo de retorno (<E> en el ejemplo).
2. Uno o más parámetros de tipo separados por comas. Un parámetro de tipo (type variable) es un identificador que nombra un tipo genérico.
3. Los parámetros de tipo pueden usarse como tipo de retorno y como placeholders para los tipos de argumentos (argumentos de tipo reales).
4. El cuerpo del método se declara igual que cualquier otro. Los parámetros de tipo solo representan tipos de referencia, no primitivos (int, double, char).

Ejemplo: Imprimir Arrays de Diferentes Tipos

public class GenericMethodTest {
    // Método genérico printArray
    public static  void printArray(E[] inputArray) {
        for (E element : inputArray) {
            System.out.printf("%s ", element);
        }
        System.out.println();
    }

    public static void main(String args[]) {
        Integer[] intArray = { 1, 2, 3, 4, 5 };
        Double[] doubleArray = { 1.1, 2.2, 3.3, 4.4 };
        Character[] charArray = { 'H', 'E', 'L', 'L', 'O' };

        System.out.println("Array integerArray contiene:");
        printArray(intArray);

        System.out.println("\nArray doubleArray contiene:");
        printArray(doubleArray);

        System.out.println("\nArray characterArray contiene:");
        printArray(charArray);
    }
}

Salida:

Array integerArray contiene: 1 2 3 4 5
Array doubleArray contiene: 1.1 2.2 3.3 4.4
Array characterArray contiene: H E L L O

Parámetros de Tipo Acotados (Bounded Type Parameters)

Para restringir los tipos permitidos para un parámetro de tipo. Ejemplo: un método que opera sobre números solo acepta Number o subclases.

Sintaxis: <T extends UpperBound>. extends significa "extiende" (clases) o "implementa" (interfaces).

Ejemplo: Máximo de Tres Objetos Comparable

public class MaximumTest {
    // T debe implementar Comparable
    public static > T maximum(T x, T y, T z) {
        T max = x;
        if (y.compareTo(max) > 0) max = y;
        if (z.compareTo(max) > 0) max = z;
        return max;
    }

    public static void main(String args[]) {
        System.out.printf("Max de %d, %d y %d es %d\n\n", 3, 4, 5, maximum(3, 4, 5));
        System.out.printf("Max de %.1f, %.1f y %.1f es %.1f\n\n", 6.6, 8.8, 7.7, maximum(6.6, 8.8, 7.7));
        System.out.printf("Max de %s, %s y %s es %s\n", "pera", "manzana", "naranja", maximum("pera", "manzana", "naranja"));
    }
}

Salida:

Max de 3, 4 y 5 es 5
Max de 6.6, 8.8 y 7.7 es 8.8
Max de pera, manzana y naranja es pera

Clases Genéricas

Una declaración de clase genérica se parece a una no genérica, pero el nombre de la clase va seguido de una sección de parámetros de tipo.

Puede tener uno o más parámetros de tipo separados por comas. Se llaman clases parametrizadas o tipos parametrizados.

Ejemplo: Clase Box<T>

public class Box {
    private T t;

    public void add(T t) { this.t = t; }
    public T get() { return t; }

    public static void main(String[] args) {
        Box integerBox = new Box<>();
        Box stringBox = new Box<>();

        integerBox.add(10);
        stringBox.add("Hola Mundo");

        System.out.printf("Valor Integer: %d\n\n", integerBox.get());
        System.out.printf("Valor String: %s\n", stringBox.get());
    }
}

Salida:

Valor Integer: 10
Valor String: Hola Mundo

Características Avanzadas (Resumen)

• Múltiples parámetros de tipo: class Pair { ... }
• Wildcards (comodines): , (upper bounded), (lower bounded).
• Type Erasure (Borrado de tipos): La información de genéricos se elimina en tiempo de ejecución; solo existe en compilación.
• Restricciones: No se pueden crear arrays de tipos genéricos concretos (new T[10] ilegal); no instanciar parámetros de tipo (new T() ilegal); no usar genéricos con excepciones (catch).