Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

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

Fontes