Baza znanjaCentar za ispite
HRHrvatski
Odaberi jezik13

CKTIS / Java

Ispitivanje generičkih nadklasa i sučelja u Javi

Pročitaj deklarirane tipove izravne nadklase i sučelja te saznaj zašto klasa obične instance `ArrayList<String>` pri izvođenju ne otkriva argument `String`.

Verzija: Java SE 21

Sintaksa

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

Class.getGenericSuperclass() vraća izravnu nadklasu kao java.lang.reflect.Type. Za Object, sučelja, primitivne tipove i void vraća null, a za tipove polja vraća Object.class.

Class.getGenericInterfaces() vraća Type[] sa sučeljima koja klasa izravno implementira ili koja sučelje izravno proširuje, redoslijedom iz deklaracije. Metoda ne prolazi kroz hijerarhiju. Ako takvih sučelja nema, što vrijedi i za primitivne tipove i void, polje je prazno. Za tipove polja rezultat sadrži prvo Cloneable, a zatim java.io.Serializable.

Za razliku od getSuperclass() i getInterfaces(), koji vraćaju objekte Class bez tipskih argumenata, generičke metode mogu dati ParameterizedType, kod sučelja kao element polja. Prije poziva getActualTypeArguments() provjeri tip pomoću instanceof ParameterizedType. Argumenti su vrijednosti tipa Type: mogu predstavljati konkretne klase, ugniježđene parametrizirane tipove ili tipske varijable. Sirovi nadtip poput List bez argumenata predstavljen je objektom Class.

Te metode čitaju potpise deklaracija, a ne tipske argumente pojedinih instanci. Zbog brisanja tipova new ArrayList<String>().getClass() daje istu klasu kao ArrayList.class: njezina je nadklasa AbstractList<E>, pri čemu je E instanca tipa TypeVariable, a ne String. Nasuprot tome, podklasa koja deklarira extends ArrayList<String> bilježi String u vlastitom potpisu.

Obje metode mogu baciti GenericSignatureFormatError zbog nevaljanog formata potpisa, TypeNotPresentException ako nedostaje tip na koji se potpis poziva ili MalformedParameterizedTypeException ako nije moguće konstruirati parametrizirani tip.

Primjeri

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<?>));
    }
}

Rezultat

Names superclass argument is String: true
Names interface argument is Integer: true
ArrayList superclass argument is a type variable: true

`Names` deklarira točno jedno izravno sučelje pa primjer koristi indeks `0`. Prve dvije provjere čitaju `String` i `Integer` iz deklaracije klase `Names`; treća potvrđuje da je argument nadklase obične `ArrayList` tipska varijabla `E`.

Povezane lekcije

  • Java · Lekcija 36 · Srednje · Verzija: 2

Izvori