O que são Genéricos e para que são utilizados?

Os genéricos em Java permitem criar classes, interfaces e métodos que funcionam com tipos parametrizados.

O principal objetivo dos genéricos:

• Aumento da segurança de tipos: O compilador verifica os tipos na fase de compilação, prevenindo ClassCastException em tempo de execução.
• Eliminação de conversões de tipos: Não é necessário fazer conversões manuais ao extrair elementos de coleções.
• Criação de código mais flexível e reutilizável: Pode-se escrever algoritmos e estruturas de dados genéricos aplicáveis a diferentes tipos de dados.

Exemplo sem genéricos:

// Antes do Java 5
import java.util.ArrayList;
import java.util.List;

public class OldStyleList {
    public static void main(String[] args) {
        List list = new ArrayList(); // sem tipagem
        list.add("olá");
        list.add(123); // pode adicionar qualquer objeto

        String s = (String) list.get(0); // é necessário fazer cast
        Integer i = (Integer) list.get(1); // é necessário fazer cast

        // Pode ocorrer erro de cast
        // String error = (String) list.get(1); // ClassCastException
        System.out.println(s);
        System.out.println(i);
    }
}

Exemplo com genéricos:

// Com genéricos
import java.util.ArrayList;
import java.util.List;

public class GenericList {
    public static void main(String[] args) {
        List<String> list = new ArrayList<>(); // lista de strings
        list.add("olá");
        // list.add(123); // erro de compilação - não pode adicionar Integer

        String s = list.get(0); // sem necessidade de cast

        // Não é possível adicionar outro tipo, previne erros
        // List<Integer> intList = new ArrayList<>();
        // intList.add("mundo"); // erro de compilação
        System.out.println(s);
    }
}

Os genéricos também são usados em:

• Classes: ArrayList<E>, HashMap<K, V>
• Interfaces: List<E>, Map<K, V>
• Métodos: <T> void printArray(T[] array)
• Restrições de tipos: <T extends Comparable<T>> (restrição a tipos que implementam Comparable)

A implementação de genéricos em Java é baseada na "apagamento de tipos" (type erasure) na fase de compilação. Isso significa que a informação sobre os tipos genéricos é removida, e em tempo de execução a JVM opera com tipos brutos. Isso garante compatibilidade com versões antigas do Java, mas possui algumas limitações.