Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Borrado de tipos y tokens de clase en Java

Por el borrado de tipos, `ArrayList<String>` y `ArrayList<Integer>` tienen la misma clase en tiempo de ejecución. La reflexión aún puede leer un argumento de tipo de la declaración de un campo.

Versión: Java SE 21

Sintaxis

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

El compilador comprueba los tipos genéricos antes del borrado. Tanto ArrayList<String> como ArrayList<Integer> se borran a ArrayList. Una variable de tipo se reduce al borrado de su primer límite (Object si no hay un límite explícito). Los objetos creados directamente con ambas parametrizaciones devuelven el mismo objeto Class mediante getClass().

Un tipo reificable está disponible por completo en tiempo de ejecución. List<?> es reificable; List<String> no lo es. Si value se declara como Object, value instanceof List<?> solo comprueba si el objeto implementa List; value instanceof List<String> no compila. Java SE 21 admite algunas pruebas instanceof con tipos parametrizados según el tipo estático del operando, pero esas pruebas tampoco comprueban los argumentos de tipo borrados.

Un token de clase es un objeto Class. El literal String.class tiene tipo Class<String>, y List.class representa la interfaz List sin argumentos de tipo. Ni List<String>.class ni List<?>.class son literales válidos: ser reificable no basta. Class.cast comprueba la compatibilidad con la clase o interfaz representada, no los tipos de los elementos de una lista.

El borrado no elimina toda la información genérica. Para un campo declarado como List<String>, el atributo Signature del archivo de clase conserva el tipo declarado. Field.getType() devuelve List.class, mientras que Field.getGenericType() devuelve un ParameterizedType del que se puede leer el argumento String. Esto describe la declaración del campo, no el objeto almacenado en él en ese momento.

Ejemplos

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

Los dos primeros resultados se refieren a la clase de los objetos en tiempo de ejecución. Los dos últimos contrastan el tipo borrado del campo con el argumento de tipo guardado en su declaración.

Lecciones relacionadas

  • Java · Lección 13 · Avanzado · Versión: 2

Fuentes