¿Qué capacidades ofrecen los Genéricos en Java?

Los genéricos en Java mejoran la seguridad de tipos del código, previniendo errores en tiempo de ejecución relacionados con el conversión de tipos. Las principales capacidades:

• Verificación de tipos en tiempo de compilación: El compilador verifica el uso correcto de los tipos especificados en los genéricos, lo que permite detectar errores antes de ejecutar el programa.

  // Sin genéricos - posible ClassCastException
  List list = new ArrayList();
  list.add("cadena");
  list.add(123); // Añadiendo un Integer
  String s = (String) list.get(1); // Error en tiempo de ejecución
  
  // Con genéricos - error de compilación
  List<String> stringList = new ArrayList<>();
  stringList.add("cadena");
  // stringList.add(123); // Error de compilación
  String str = stringList.get(0); // Obtención segura
  

• Eliminación de conversiones de tipos (type casting): Los genéricos eliminan la necesidad de realizar conversiones explícitas al obtener elementos de colecciones o usar clases parametrizadas.

  // Sin genéricos
  List list = new ArrayList();
  list.add("Hola");
  String s = (String) list.get(0); // Conversión explícita
  
  // Con genéricos
  List<String> stringList = new ArrayList<>();
  stringList.add("Hola");
  String str = stringList.get(0); // No se requiere conversión
  

• Implementación de código genérico (Métodos Genéricos, Clases Genéricas, Interfaces Genéricas): Permiten crear algoritmos y estructuras de datos genéricos que trabajan con diferentes tipos sin duplicar código.

  // Método genérico para imprimir un array
  public static <T> void printArray(T[] array) {
      for (T element : array) {
          System.out.print(element + " ");
      }
      System.out.println();
  }
  
  // Clase genérica - par de valores
  class Pair<K, V> {
      private K key;
      private V value;
  
      public Pair(K key, V value) {
          this.key = key;
          this.value = value;
      }
  
      public K getKey() { return key; }
      public V getValue() { return value; }
  }
  

• Soporte para comodines (Wildcards): Permiten definir restricciones flexibles en los tipos en tipos parametrizados.

  • ? (Wildcard sin límites): Cualquier tipo.
  • ? extends T (Wildcard con límite superior): El tipo debe ser T o un subtipo de T.
  • ? super T (Wildcard con límite inferior): El tipo debe ser T o un supertipo de T.

  // Método que acepta una lista de cualquier tipo
  public static void processList(List<?> list) {
      // ...
  }
  
  // Método que acepta una lista de números o sus subtipos
  public static void processNumbers(List<? extends Number> list) {
      // ...
  }
  
  // Método que acepta una lista de cadenas o sus supertipos
  public static void addStrings(List<? super String> list) {
      list.add("nueva cadena");
  }
  

• Uso en el marco de colecciones: Todas las clases principales de colecciones (List, Set, Map, etc.) son parametrizadas, lo que hace que trabajar con colecciones sea seguro en tipos y conveniente.

Los genéricos son un elemento clave de Java moderno, que aumenta la fiabilidad y la legibilidad del código.