¿Qué son los genéricos y por qué utilizarlos?

Question

Accepted Answer

Los **genéricos** permiten escribir clases, interfaces y métodos que funcionan con un **parámetro de tipo** especificado por el llamador — proporcionando **seguridad de tipos en tiempo de compilación** y eliminando la necesidad de conversiones de tipos. Impulsan el Collections Framework y las bibliotecas reutilizables. ## Por qué es importante ```java // ❌ before generics (or with raw types) — no type safety, requires casts List list = new ArrayList(); list.add("hello"); list.add(42); // oops — anything can go in String s = (String) list.get(1); // ClassCastException at RUNTIME! 💥 // ✅ with generics — the type is enforced at COMPILE time List list = new ArrayList<>(); list.add("hello"); list.add(42); // ❌ compile error — caught immediately String s = list.get(0); // no cast needed — known to be String ``` Los genéricos mueven los errores de tipo del tiempo de ejecución (`ClassCastException`) al **tiempo de compilación**, y eliminan la necesidad de conversiones manuales — haciendo el código más seguro y limpio. ## Clases y métodos genéricos ```java // a generic class — T is a type parameter filled in by the user public class Box { private T value; public void set(T value) { this.value = value; } public T get() { return value; } } Box b = new Box<>(); // T = String b.set("hi"); String x = b.get(); // typed, no cast // a generic method public static T firstElement(List list) { return list.get(0); } ``` ## Parámetros de tipo acotados ```java // T must be Number (or a subclass) — lets you call Number methods public static double sum(List list) { double total = 0; for (T n : list) total += n.doubleValue(); // safe — T is a Number return total; } ``` `` restringe el parámetro de tipo, permitiéndote utilizar de forma segura los miembros de ese tipo. ## Comodines (Wildcards) ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` Los comodines añaden flexibilidad para parámetros de método que deben aceptar rangos de tipos. ## Borrado de tipos (una advertencia de Java) ```java // generics are a COMPILE-TIME feature — erased at runtime (for backward compatibility) List a = new ArrayList<>(); List b = new ArrayList<>(); a.getClass() == b.getClass(); // true — both are just ArrayList at runtime // consequence: can't do `new T()` or `instanceof List` ``` Java implementa genéricos mediante **borrado de tipos** — los parámetros de tipo existen en tiempo de compilación pero se eliminan en tiempo de ejecución, lo que tiene algunas limitaciones. ## Por qué es importante Los genéricos son esenciales para Java moderno — proporcionan seguridad de tipos en tiempo de compilación (detectando errores de tipo temprano en lugar de como `ClassCastException` en tiempo de ejecución), eliminan conversiones de tipos verbosas y propensas a errores, y permiten código reutilizable y flexible en cuanto a tipos. Son la base de todo el Collections Framework (`List`, `Map`) e incontables bibliotecas. Comprender clases y métodos genéricos, parámetros acotados, comodines (PECS) y la advertencia de borrado de tipos te permite tanto usar correctamente las API genéricas como diseñar tus propias abstracciones reutilizables y type-safe — una habilidad central para escribir Java robusto y mantenible.