Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Apagamento de tipos e tokens de classe em Java

O apagamento de tipos faz com que `ArrayList<String>` e `ArrayList<Integer>` tenham a mesma classe em tempo de execução. A reflexão pode, ainda assim, ler um argumento de tipo da declaração de um campo.

Versão: Java SE 21

Sintaxe

List<String> names = new ArrayList<>();
Class<String> stringToken = String.class;
Class<?> listToken = List.class;
Class<?> runtimeClass = names.getClass();
boolean isList = value instanceof List<?>; // value has static type Object
Type declaredType = field.getGenericType(); // field is a java.lang.reflect.Field

O compilador verifica os tipos genéricos antes do apagamento. Tanto ArrayList<String> como ArrayList<Integer> se reduzem a ArrayList. Uma variável de tipo reduz-se ao resultado do apagamento do seu primeiro limite (Object se não houver um limite explícito). Os objetos criados diretamente com essas duas parametrizações devolvem o mesmo objeto Class através de getClass().

Um tipo reificável está totalmente disponível em tempo de execução. List<?> é reificável; List<String> não. Se value for declarado como Object, value instanceof List<?> apenas verifica se o objeto implementa List; value instanceof List<String> não compila. O Java SE 21 permite alguns testes instanceof com tipos parametrizados consoante o tipo estático do operando, mas esses testes não verificam os argumentos de tipo apagados.

Um token de classe é um objeto Class. O literal String.class tem o tipo Class<String>, e List.class representa a interface List sem argumentos de tipo. Nem List<String>.class nem List<?>.class são literais válidos: não basta que o tipo seja reificável. Class.cast verifica a compatibilidade com a classe ou interface representada, não os tipos dos elementos de uma lista.

O apagamento não elimina toda a informação genérica. Num campo declarado como List<String>, o atributo Signature do ficheiro de classe conserva o tipo declarado. Field.getType() devolve List.class, enquanto Field.getGenericType() devolve um ParameterizedType a partir do qual se pode ler o argumento String. Esta informação descreve a declaração do campo, não o objeto que nele está guardado naquele momento.

Exemplos

import java.lang.reflect.Field;
import java.lang.reflect.ParameterizedType;
import java.util.ArrayList;
import java.util.List;

public class TypeErasureDemo {
    private List<String> names = new ArrayList<>();

    public static void main(String[] args) throws NoSuchFieldException {
        var strings = new ArrayList<String>();
        var integers = new ArrayList<Integer>();
        System.out.println("Same runtime class: " + (strings.getClass() == integers.getClass()));
        System.out.println("Matches ArrayList.class: " + (strings.getClass() == ArrayList.class));

        Field field = TypeErasureDemo.class.getDeclaredField("names");
        System.out.println("Erased field type is List: " + (field.getType() == List.class));
        // This field is known to have a parameterized declaration.
        ParameterizedType declaredType = (ParameterizedType) field.getGenericType();
        System.out.println("Declared type argument is String: "
                + (declaredType.getActualTypeArguments()[0] == String.class));
    }
}

Resultado

Same runtime class: true
Matches ArrayList.class: true
Erased field type is List: true
Declared type argument is String: true

Os dois primeiros resultados dizem respeito à classe dos objetos em tempo de execução. Os dois últimos distinguem o tipo apagado do campo do argumento de tipo conservado na declaração.

Lições relacionadas

  • Java · Lição 13 · Avançado · Versão: 2

Fontes