Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Inspección de superclases e interfaces genéricas en Java

Lee los tipos declarados de la superclase directa y de las interfaces directas, y descubre por qué la clase en tiempo de ejecución de una `ArrayList<String>` normal no revela el argumento `String`.

Versión: Java SE 21

Sintaxis

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

Class.getGenericSuperclass() devuelve la superclase directa como java.lang.reflect.Type. Devuelve null para Object, las interfaces, los tipos primitivos y void, y Object.class para los tipos de array.

Class.getGenericInterfaces() devuelve un Type[] con las interfaces que una clase implementa directamente o que una interfaz extiende directamente, en orden de declaración. No recorre la jerarquía. Si no hay tales interfaces, como ocurre con los tipos primitivos y void, el array está vacío. Para los tipos de array, el resultado contiene Cloneable y después java.io.Serializable.

A diferencia de getSuperclass() y getInterfaces(), que devuelven objetos Class sin argumentos de tipo, los métodos genéricos pueden proporcionar un ParameterizedType, como elemento del array en el caso de las interfaces. Comprueba el tipo con instanceof ParameterizedType antes de llamar a getActualTypeArguments(). Los argumentos son valores Type: pueden representar clases concretas, tipos parametrizados anidados o variables de tipo. Un supertipo sin parametrizar como List sin argumentos se representa mediante Class.

Estos métodos leen las firmas de las declaraciones, no los argumentos de tipo de cada instancia. Por el borrado de tipos, new ArrayList<String>().getClass() devuelve la misma clase que ArrayList.class: su superclase es AbstractList<E>, donde E es una TypeVariable, no String. En cambio, una subclase que declara extends ArrayList<String> registra String en su propia firma.

Ambos métodos pueden lanzar GenericSignatureFormatError si el formato de la firma no es válido, TypeNotPresentException si falta un tipo referenciado o MalformedParameterizedTypeException si no se puede construir un tipo parametrizado.

Ejemplos

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 exactamente una interfaz directa, por eso el ejemplo usa el índice `0`. Las dos primeras comprobaciones leen `String` e `Integer` de la declaración de `Names`; la tercera confirma que el argumento de la superclase de una `ArrayList` normal es la variable de tipo `E`.

Lecciones relacionadas

  • Java · Lección 36 · Intermedio · Versión: 2

Fuentes