Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Ispezionare superclassi e interfacce generiche in Java

Leggi i tipi dichiarati della superclasse diretta e delle interfacce dirette e scopri perché la classe a runtime di una normale `ArrayList<String>` non rivela l’argomento `String`.

Versione: Java SE 21

Sintassi

public java.lang.reflect.Type getGenericSuperclass()
public java.lang.reflect.Type[] getGenericInterfaces()

Class.getGenericSuperclass() restituisce la superclasse diretta come java.lang.reflect.Type. Restituisce null per Object, le interfacce, i tipi primitivi e void, e Object.class per i tipi array.

Class.getGenericInterfaces() restituisce un Type[] contenente, nell’ordine di dichiarazione, le interfacce che una classe implementa direttamente o che un’interfaccia estende direttamente. Non percorre la gerarchia. Se non ci sono interfacce di questo tipo, come per i primitivi e void, l’array è vuoto. Per i tipi array, il risultato contiene Cloneable seguito da java.io.Serializable.

A differenza di getSuperclass() e getInterfaces(), che restituiscono oggetti Class senza argomenti di tipo, i metodi generici possono fornire un ParameterizedType, come elemento dell’array nel caso delle interfacce. Verifica il tipo con instanceof ParameterizedType prima di chiamare getActualTypeArguments(). Gli argomenti sono valori Type: possono rappresentare classi concrete, tipi parametrizzati annidati o variabili di tipo. Un supertipo raw come List senza argomenti è rappresentato da Class.

Questi metodi leggono le firme delle dichiarazioni, non gli argomenti di tipo delle singole istanze. Per via della cancellazione dei tipi, new ArrayList<String>().getClass() restituisce la stessa classe di ArrayList.class: la sua superclasse è AbstractList<E>, dove E è una TypeVariable, non String. Una sottoclasse che dichiara extends ArrayList<String>, invece, registra String nella propria firma.

Entrambi i metodi possono lanciare GenericSignatureFormatError se il formato della firma non è valido, TypeNotPresentException se manca un tipo referenziato o MalformedParameterizedTypeException se non è possibile costruire un tipo parametrizzato.

Esempi

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;
import java.lang.reflect.TypeVariable;
import java.util.ArrayList;

public class GenericSupertypesDemo {
    interface Tagged<T> {}

    static final class Names extends ArrayList<String> implements Tagged<Integer> {}

    private static Type singleArgument(Type type) {
        if (type instanceof ParameterizedType parameterized) {
            Type[] arguments = parameterized.getActualTypeArguments();
            if (arguments.length == 1) {
                return arguments[0];
            }
        }
        throw new IllegalArgumentException("Expected a type with one type argument");
    }

    public static void main(String[] args) {
        Type parent = Names.class.getGenericSuperclass();
        Type tagged = Names.class.getGenericInterfaces()[0];
        Type plainParent = new ArrayList<String>().getClass().getGenericSuperclass();

        System.out.println("Names superclass argument is String: "
                + String.class.equals(singleArgument(parent)));
        System.out.println("Names interface argument is Integer: "
                + Integer.class.equals(singleArgument(tagged)));
        System.out.println("ArrayList superclass argument is a type variable: "
                + (singleArgument(plainParent) instanceof TypeVariable<?>));
    }
}

Risultato

Names superclass argument is String: true
Names interface argument is Integer: true
ArrayList superclass argument is a type variable: true

`Names` dichiara esattamente un’interfaccia diretta, quindi l’esempio usa l’indice `0`. I primi due controlli leggono `String` e `Integer` dalla dichiarazione di `Names`; il terzo conferma che l’argomento della superclasse di una normale `ArrayList` è la variabile di tipo `E`.

Lezioni correlate

  • Java · Lezione 36 · Intermedio · Versione: 2

Fonti