Generics em Java: classes e métodos com segurança de tipos

Por que os generics existem

Um tipo genérico permite escrever o código uma vez e reutilizá-lo para muitos tipos sem abrir mão da segurança de tipos. Em vez de escrever uma IntBox, uma StringBox e uma UserBox separadas, você escreve uma única Box<T> na qual T é um espaço reservado que quem chama preenche.

Você já usou generics toda vez que escreveu ArrayList<String> ou HashMap<String, Integer>. A parte <...> é um argumento de tipo. Esta página mostra como escrever os seus próprios.

A alternativa - armazenar tudo como Object - joga fora a informação de tipo e força conversões feias e propensas a erro:

import java.util.ArrayList;
import java.util.List;

public class Main {
    public static void main(String[] args) {
        List<Object> raw = new ArrayList<>();
        raw.add("hello");
        raw.add(42);                       // nada impede esse erro

        String first = (String) raw.get(0); // toda leitura precisa de uma conversão
        String oops = (String) raw.get(1);  // compila, depois quebra em tempo de execução
        System.out.println(first + " " + oops);
    }
}

Essa conversão na última linha lança uma ClassCastException em tempo de execução - exatamente o tipo de bug que os generics foram projetados para tornar impossível.

Uma classe genérica

Declare um parâmetro de tipo entre colchetes angulares após o nome da classe. Por convenção, é uma única letra maiúscula: T de "type" (tipo), E de "element" (elemento), K/V para chave/valor.

class Box<T> {
    private T value;

    Box(T value) { this.value = value; }

    T get() { return value; }
    void set(T value) { this.value = value; }
}

public class Main {
    public static void main(String[] args) {
        Box<String> name = new Box<>("Coddy");
        Box<Integer> count = new Box<>(3);

        String s = name.get();     // sem conversão - o compilador sabe que é uma String
        int n = count.get();
        System.out.println(s + " x" + n);

        // name.set(99); // não compila - Box<String> só aceita Strings
    }
}

Dentro de Box, cada T se torna o que quer que quem chama tenha fornecido. Box<String> é uma caixa que só guarda e retorna String. O compilador rejeita name.set(99) antes mesmo de o programa rodar.

Os <> vazios à direita (o operador diamante) permitem que o compilador infira o argumento de tipo a partir do lado esquerdo, então você não repete <String> duas vezes.

Métodos genéricos

Um único método pode ter o seu próprio parâmetro de tipo, independente da classe. Coloque o parâmetro <T> antes do tipo de retorno:

import java.util.List;

public class Main {

    // <T> declara o parâmetro de tipo; T é o tipo do elemento
    static <T> T firstOrNull(List<T> items) {
        return items.isEmpty() ? null : items.get(0);
    }

    public static void main(String[] args) {
        List<String> words = List.of("alpha", "beta");
        List<Integer> nums = List.of(10, 20, 30);

        String w = firstOrNull(words);   // T inferido como String
        Integer n = firstOrNull(nums);   // T inferido como Integer
        System.out.println(w + " " + n);
    }
}

Você nunca passa T explicitamente - o compilador o infere a partir do argumento. Métodos genéricos são como utilitários como Collections.sort ou List.of permanecem seguros em termos de tipo com qualquer tipo de elemento.

Parâmetros de tipo limitados

Às vezes um tipo genérico só faz sentido para alguns tipos. extends restringe o parâmetro para que você possa chamar os métodos do limite. Aqui T extends Number significa que T é Number ou qualquer subclasse (Integer, Double, ...), então doubleValue() fica disponível:

import java.util.List;

public class Main {

    static <T extends Number> double sum(List<T> numbers) {
        double total = 0;
        for (T n : numbers) {
            total += n.doubleValue();   // válido porque T é no mínimo um Number
        }
        return total;
    }

    public static void main(String[] args) {
        System.out.println(sum(List.of(1, 2, 3)));        // Integers
        System.out.println(sum(List.of(1.5, 2.5)));       // Doubles
    }
}

Observe que extends aqui significa "é um subtipo de", e funciona tanto para classes quanto para interfaces - <T extends Comparable<T>> é extremamente comum quando você precisa comparar elementos.

Curingas: ? extends e ? super

Uma sutileza traiçoeira: List<Integer> não é uma List<Number>, mesmo que Integer seja um Number. Os generics são invariantes. Os curingas relaxam isso quando você só precisa ler ou só precisa escrever.

Use ? extends T para um produtor do qual você lê, e ? super T para um consumidor no qual você escreve (a regra "PECS" - Producer Extends, Consumer Super):

import java.util.ArrayList;
import java.util.List;

public class Main {

    // lê Numbers - aceita List<Integer>, List<Double>, etc.
    static double total(List<? extends Number> nums) {
        double sum = 0;
        for (Number n : nums) sum += n.doubleValue();
        return sum;
    }

    // escreve Integers - aceita List<Integer>, List<Number>, List<Object>
    static void addInts(List<? super Integer> dest) {
        dest.add(1);
        dest.add(2);
    }

    public static void main(String[] args) {
        List<Integer> ints = List.of(1, 2, 3);
        System.out.println(total(ints));      // funciona graças a ? extends

        List<Number> bucket = new ArrayList<>();
        addInts(bucket);                       // funciona graças a ? super
        System.out.println(bucket);
    }
}

Uma lista ? extends Number deixa você ler os elementos como Number, mas não adicionar a ela (o compilador não tem como saber o tipo exato do elemento). Uma lista ? super Integer deixa você adicionar Integer, mas as leituras voltam como Object. Escolha o curinga que combina com a forma como os dados fluem.

Apagamento de tipos e seus limites

Os generics são um recurso de tempo de compilação. Depois da compilação, o parâmetro de tipo é apagado - em tempo de execução Box<String> e Box<Integer> são ambas apenas Box. Isso mantém os generics compatíveis com código antigo, mas impõe limites reais.

// Nenhum destes compila - o parâmetro de tipo não existe em tempo de execução:
T value = new T();          // não dá para instanciar um parâmetro de tipo
T[] array = new T[10];      // não dá para criar um array genérico
if (list instanceof List<String>) { } // não dá para testar o argumento de tipo

Como o tipo desaparece em tempo de execução, você não pode perguntar "o que era T?" via reflexão, e não pode sobrecarregar métodos que diferem apenas pelo seu argumento genérico (foo(List<String>) e foo(List<Integer>) são apagados para a mesma assinatura). Quando você realmente precisa do tipo em tempo de execução, passe um token Class<T> como parâmetro do construtor ou do método.

Próximo: expressões lambda

Você viu que um método genérico recebe um tipo como parâmetro. O próximo passo é tratar o comportamento como parâmetro. As expressões lambda permitem passar um trecho de código - uma função - para um método, que é exatamente como você vai ordenar, filtrar e transformar as coleções genéricas que acabou de aprender a tipar com segurança.