¿Qué es un comodín en Java?

El comodín (?) en Java se utiliza en genéricos para representar un tipo desconocido. Permite trabajar con colecciones que contienen elementos de diferentes tipos compatibles, sin estar estrictamente ligados a un tipo específico.

Los escenarios principales de uso:

1. ? (comodín con límite superior): Indica cualquier tipo que sea un subclase o implemente la interfaz especificada. Se usa para leer datos de una colección. Ejemplo: List<? extends Number> puede contener List<Integer>, List<Double>, .getList<Long>.

   // Lectura de una colección con límite superior
   public void processNumbers(List<? extends Number> numbers) {
       for (Number n : numbers) {
           System.out.println(n);
       }
       // numbers.add(new Integer(10)); // Error de compilación - no se pueden agregar elementos
   }
   

2. ? super (comodín con límite inferior): Indica cualquier tipo que sea un supertipo de la clase/interfaz especificada o esa misma clase/interfaz. Se usa para escribir en una colección (principio PECS: Productor Extends, Consumidor Super). Ejemplo: List<? super Integer> puede contener List<Integer>, List<Number>, List<Object>.

   // Escribir en una colección con límite inferior
   public void addIntegers(List<? super Integer> list) {
       list.add(1);
       list.add(new Integer(2));
       // Object o = list.get(0); // Devuelve Object, ya que el tipo exacto es desconocido
   }
   

3. ? (comodín sin límite): Indica cualquier tipo. Equivale a ? extends Object. Se usa cuando no importa el tipo exacto de los elementos de la colección, por ejemplo, para verificar tamaño o limpiar.

   // Trabajar con una colección de cualquier tipo
   public void printList(List<?> list) {
       for (Object obj : list) {
           System.out.println(obj);
       }
       // list.add("hello"); // Error de compilación - no se pueden agregar elementos (excepto null)
   }
   

Los comodines aumentan la flexibilidad del código, permitiendo que los métodos trabajen con un rango más amplio de tipos de colecciones, manteniendo la seguridad de tipos. Con su ayuda, se puede evitar la duplicación de código en métodos que realizan operaciones similares en colecciones de diferentes tipos compatibles.