CKTIS / Java
Inspecter les superclasses et interfaces génériques en Java
Lisez les types déclarés de la superclasse directe et des interfaces directes, et découvrez pourquoi la classe d’une instance ordinaire d’`ArrayList<String>` ne révèle pas l’argument `String`.
Version : Java SE 21
Syntaxe
public java.lang.reflect.Type getGenericSuperclass()
public java.lang.reflect.Type[] getGenericInterfaces()Class.getGenericSuperclass() renvoie la superclasse directe sous forme de java.lang.reflect.Type. La méthode renvoie null pour Object, les interfaces, les types primitifs et void, et Object.class pour les types tableau.
Class.getGenericInterfaces() renvoie un Type[] contenant, dans l’ordre de déclaration, les interfaces qu’une classe implémente directement ou qu’une interface étend directement. La méthode ne parcourt pas la hiérarchie. En l’absence de telles interfaces, notamment pour les types primitifs et void, le tableau est vide. Pour les types tableau, il contient Cloneable, puis java.io.Serializable.
Contrairement à getSuperclass() et getInterfaces(), qui renvoient des objets Class sans arguments de type, les méthodes génériques peuvent fournir un ParameterizedType, comme élément du tableau pour les interfaces. Vérifiez le type avec instanceof ParameterizedType avant d’appeler getActualTypeArguments(). Les arguments sont des valeurs Type qui peuvent représenter des classes concrètes, des types paramétrés imbriqués ou des variables de type. Un supertype brut comme List sans argument est représenté par Class.
Ces méthodes lisent les signatures des déclarations, pas les arguments de type propres à chaque instance. Du fait de l’effacement des types, new ArrayList<String>().getClass() renvoie la même classe qu’ArrayList.class : sa superclasse est AbstractList<E>, où E est une TypeVariable, et non String. En revanche, une sous-classe qui déclare extends ArrayList<String> inscrit String dans sa propre signature.
Les deux méthodes peuvent lever GenericSignatureFormatError si le format de la signature est invalide, TypeNotPresentException si un type référencé manque ou MalformedParameterizedTypeException si un type paramétré ne peut pas être construit.
Exemples
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<?>));
}
}Résultat
Names superclass argument is String: true Names interface argument is Integer: true ArrayList superclass argument is a type variable: true
`Names` déclare exactement une interface directe, d’où l’indice `0`. Les deux premiers tests lisent `String` et `Integer` dans la déclaration de `Names` ; le troisième confirme que l’argument de la superclasse d’une `ArrayList` ordinaire est la variable de type `E`.
Leçons associées
- Java · Leçon 36 · Intermédiaire · Version : 2