Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Cancellazione dei tipi e token di classe in Java

Per effetto della cancellazione dei tipi, `ArrayList<String>` e `ArrayList<Integer>` hanno la stessa classe a runtime. La riflessione può comunque leggere un argomento di tipo dalla dichiarazione di un campo.

Versione: Java SE 21

Sintassi

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

Il compilatore controlla i tipi generici prima della cancellazione. Sia ArrayList<String> sia ArrayList<Integer> si riducono ad ArrayList. Una variabile di tipo si riduce al tipo ottenuto applicando la cancellazione al suo primo limite (Object se non ne è dichiarato uno). Gli oggetti creati direttamente con le due parametrizzazioni restituiscono lo stesso oggetto Class tramite getClass().

Un tipo reificabile è disponibile per intero a runtime. List<?> è reificabile, List<String> no. Se value è dichiarato come Object, value instanceof List<?> verifica solo se l’oggetto implementa List; value instanceof List<String> non compila. Java SE 21 ammette alcune verifiche instanceof con tipi parametrizzati in base al tipo statico dell’operando, ma non controlla gli argomenti di tipo cancellati.

Un token di classe è un oggetto Class. Il letterale String.class ha tipo Class<String> e List.class rappresenta l’interfaccia List senza argomenti di tipo. Né List<String>.class né List<?>.class sono letterali validi: la reificabilità da sola non basta. Class.cast controlla la compatibilità con la classe o l’interfaccia rappresentata, non il tipo degli elementi di una lista.

La cancellazione non elimina tutte le informazioni generiche. Per un campo dichiarato come List<String>, l’attributo Signature del file di classe conserva il tipo dichiarato. Field.getType() restituisce List.class, mentre Field.getGenericType() restituisce un ParameterizedType da cui si può leggere l’argomento String. Questa informazione descrive la dichiarazione del campo, non l’oggetto che il campo contiene in quel momento.

Esempi

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));
    }
}

Risultato

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

I primi due risultati riguardano la classe degli oggetti a runtime. Gli ultimi due mettono a confronto il tipo cancellato del campo e l’argomento di tipo conservato nella dichiarazione.

Lezioni correlate

  • Java · Lezione 13 · Avanzato · Versione: 2

Fonti