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