**Generics** permitem que você escreva classes e métodos parametrizados por *tipo*, de modo que o mesmo código funcione com muitos tipos enquanto mantém **segurança de tipo em tempo de compilação**. Este é **polimorfismo paramétrico** — "uma forma, qualquer tipo". ## Por que isso importa ```java // Without generics: untyped, needs casts, can break at runtime List list = new ArrayList(); list.add("hi"); String s = (String) list.get(0); // cast required; wrong type → ClassCastException ``` ```java // With generics: type is known and checked at compile time List list = new ArrayList<>(); list.add("hi"); String s = list.get(0); // no cast; list.add(42) won't compile ``` ## Escrevendo um tipo genérico ```java class Box { // T is a type parameter private T value; Box(T value) { this.value = value; } T get() { return value; } } Box b = new Box<>(42); // T = Integer, checked at compile time int n = b.get(); // no cast needed ``` ## Limites e variância (brevemente) ```java > // bounded: T must be comparable List // covariance: accept List, List ``` ## Armadilha Java apaga tipos genéricos em tempo de execução (*type erasure*) — você não pode fazer `new T()` ou `instanceof List`. C++ templates e C# generics se comportam de forma diferente (monomorphization / reified types). ## Por que isso importa Generics oferecem reutilização *e* segurança simultaneamente: um `List` serve para cada tipo de elemento, com o compilador capturando erros de tipo que seriam falhas em tempo de execução. Eles eliminam conversões inseguras e são a base das coleções, tornando o código tanto mais reutilizável quanto mais difícil de usar incorretamente.

Programação Orientada a Objetos perguntas