Definición de genéricos en Java

Empecemos con una pequeña definición de interfaces List e Iterator en el paquete java.util.

public interface List<E> {
    void add(E x);
    Iterator<E> iterator();
}

public interface Iterator<E> {
    E next();
    boolean hasNext();
}

Todo este código debería ser familiar, excepto por las partes entre los ángulos <>. Estas son las declaraciones de los parámetros de tipo formales de las interfaces List e Iterator.

Los parámetros de tipo se pueden usar a lo largo de la declaración genérica, prácticamente donde usaríamos tipos ordinarios.

En la introducción, vimos invocaciones de la declaración de tipo genérico List, como List<Integer>. En la invocación (usualmente llamada tipo parametrizado), todas las ocurrencias del parámetro de tipo formal (E en este caso) se reemplazan por el argumento de tipo real (en este caso, Integer).

Podríamos imaginar que List<Integer> representa una versión de List donde E ha sido reemplazado uniformemente por Integer:

public interface ListaEnteros {
    void add(Integer x);
    Iterator<Integer> iterator();
}

Esta intuición puede ser útil, pero también engañosa.

Es útil, porque el tipo parametrizado List<Integer> de hecho tiene métodos que se ven exactamente como esta expansión.

Es engañosa, porque la declaración de un genérico nunca se expande realmente de esta manera. No hay múltiples copias del código, ni en el código fuente, ni en binario, ni en disco ni en memoria.

Una declaración de tipo genérico se compila una sola vez y se convierte en un solo archivo de clase, al igual que una declaración ordinaria de clase o interfaz.

Los parámetros de tipo son análogos a los parámetros ordinarios utilizados en métodos o constructores. Así como un método tiene parámetros de valor formales que describen los tipos de valores sobre los que opera, una declaración genérica tiene parámetros de tipo formales.

Cuando se invoca un método, los argumentos reales se sustituyen por los parámetros formales, y se evalúa el cuerpo del método. Cuando se invoca una declaración genérica, los argumentos de tipo reales se sustituyen por los parámetros de tipo formales.

Una nota sobre las convenciones de nomenclatura. Se recomienda utilizar nombres concisos (de un solo carácter si es posible) pero representativos para los parámetros de tipo formales. Es mejor evitar caracteres minúsculos en esos nombres, facilitando distinguir los parámetros de tipo formales de las clases e interfaces ordinarias. Muchos tipos contenedores usan E, de element (elemento), o T, de type (tipo), como nombres de parámetro de tipo.

Ejemplo de uso de genéricos

Veamos un ejemplo de una clase genérica que implementa una pila.

public class Pila<E> {
    private List<E> elementos = new ArrayList<E>();

    public void push(E elemento) {
        elementos.add(elemento);
    }

    public E pop() {
        return elementos.remove(elementos.size() - 1);
    }

    public boolean estaVacia() {
        return elementos.isEmpty();
    }
}

Esto debemos implementarlo en su propio archivo, llamado Pila.java. Luego, en nuestro archivo App.java, podemos usar la clase Pila de la siguiente manera:

public class App {
    public static void main(String[] args) {
        Pila<Integer> pilaEnteros = new Pila<Integer>();
        pilaEnteros.push(1);
        pilaEnteros.push(2);
        pilaEnteros.push(3);

        while (!pilaEnteros.estaVacia()) {
            System.out.println(pilaEnteros.pop());
        }
    }
}

Este código imprimirá:

3
2
1

Si, en cambio, usamos Pila para almacenar cadenas, el código se vería así:

public class App {

    public static void main(String[] args) {
        Pila<String> pila = new Pila<>();
        pila.push("Hola");
        pila.push("Mundo");
        pila.push("!");
        pila.push("Java");
        while (!pila.estaVacia()) {
            System.out.println(pila.pop());
        }
    }
}

Este código imprimirá:

Java
!
Mundo
Hola