CKTIS / Java
Inspecionar superclasses e interfaces genéricas em Java
Lê os tipos declarados da superclasse direta e das interfaces diretas e percebe por que razão a classe de uma instância normal de `ArrayList<String>` não revela o argumento `String`.
Versão: Java SE 21
Sintaxe
public java.lang.reflect.Type getGenericSuperclass()
public java.lang.reflect.Type[] getGenericInterfaces()Class.getGenericSuperclass() devolve a superclasse direta como java.lang.reflect.Type. Devolve null para Object, interfaces, tipos primitivos e void, e Object.class para tipos de array.
Class.getGenericInterfaces() devolve um Type[] com as interfaces que uma classe implementa diretamente ou que uma interface estende diretamente, pela ordem da declaração. Não percorre a hierarquia. Se não houver interfaces desse género, como no caso dos tipos primitivos e de void, o array está vazio. Para tipos de array, o resultado contém Cloneable seguido de java.io.Serializable.
Ao contrário de getSuperclass() e getInterfaces(), que devolvem objetos Class sem argumentos de tipo, os métodos genéricos podem devolver um ParameterizedType, como elemento do array no caso das interfaces. Verifica o tipo com instanceof ParameterizedType antes de chamar getActualTypeArguments(). Os argumentos são valores Type: podem representar classes concretas, tipos parametrizados aninhados ou variáveis de tipo. Um supertipo em bruto, como List sem argumentos, é representado por Class.
Estes métodos leem as assinaturas das declarações, não os argumentos de tipo de cada instância. Devido ao apagamento de tipos, new ArrayList<String>().getClass() devolve a mesma classe que ArrayList.class: a sua superclasse é AbstractList<E>, em que E é uma TypeVariable, não String. Já uma subclasse que declara extends ArrayList<String> regista String na sua própria assinatura.
Ambos os métodos podem lançar GenericSignatureFormatError se o formato da assinatura for inválido, TypeNotPresentException se faltar um tipo referenciado ou MalformedParameterizedTypeException se não for possível construir um tipo parametrizado.
Exemplos
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<?>));
}
}Resultado
Names superclass argument is String: true Names interface argument is Integer: true ArrayList superclass argument is a type variable: true
`Names` declara exatamente uma interface direta, pelo que o exemplo usa o índice `0`. As duas primeiras verificações leem `String` e `Integer` da declaração de `Names`; a terceira confirma que o argumento da superclasse de uma `ArrayList` normal é a variável de tipo `E`.
Lições relacionadas
- Java · Lição 36 · Intermédio · Versão: 2