O que são genéricos e por que usá-los?

Question

Accepted Answer

**Genéricos** permitem escrever classes, interfaces e métodos que funcionam com um **parâmetro de tipo** especificado pelo chamador — fornecendo **segurança de tipo em tempo de compilação** e eliminando conversões de tipo (casts). Eles alimentam o Collections Framework e bibliotecas reutilizáveis. ## O problema que genéricos resolvem ```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 ``` Genéricos movem erros de tipo do runtime (`ClassCastException`) para **tempo de compilação**, e removem a necessidade de casts manuais — tornando o código mais seguro e limpo. ## Classes e 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 limitados ```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; } ``` `` limita o parâmetro de tipo, permitindo que você use com segurança os membros desse tipo. ## Wildcards ```java List nums; // "some subtype of Number" — read (producer) List sink; // "Integer or a supertype" — write (consumer) // PECS: Producer Extends, Consumer Super ``` Wildcards adicionam flexibilidade para parâmetros de método que devem aceitar intervalos de tipos. ## Type erasure (uma ressalva do 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 via **type erasure** — parâmetros de tipo existem em tempo de compilação mas são removidos em runtime, o que tem algumas limitações. ## Por que isso importa Genéricos são essenciais para o Java moderno — eles fornecem segurança de tipo em tempo de compilação (detectando erros de tipo cedo em vez de como `ClassCastException`s em runtime), eliminam casts verbosos e propensos a erros, e permitem código reutilizável e flexível em relação a tipos. Eles são a base de todo o Collections Framework (`List`, `Map`) e inúmeras bibliotecas. Compreender classes/métodos genéricos, parâmetros limitados, wildcards (PECS) e a ressalva de type-erasure permite que você tanto use APIs genéricas corretamente quanto projete suas próprias abstrações reutilizáveis e type-safe — uma habilidade fundamental para escrever Java robusto e fácil de manter.