Znalostná bázaCentrum skúšok
SKSlovenčina
Vybrať jazyk13

CKTIS / Java

Skúmanie generických nadtried a rozhraní v Jave

Prečítaj deklarované typy priamej nadtriedy a priamych rozhraní a zisti, prečo z triedy bežnej inštancie `ArrayList<String>` za behu nezískaš argument `String`.

Verzia: Java SE 21

Syntax

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

Class.getGenericSuperclass() vracia priamu nadtriedu ako java.lang.reflect.Type. Pre Object, rozhrania, primitívne typy a void vracia null, pre typy polí vracia Object.class.

Class.getGenericInterfaces() vracia Type[] s rozhraniami, ktoré trieda priamo implementuje alebo ktoré rozhranie priamo rozširuje, v poradí deklarácie. Neprechádza hierarchiu. Ak také rozhrania nie sú, napríklad pri primitívnych typoch a void, pole je prázdne. Pre typy polí výsledok obsahuje najprv Cloneable a potom java.io.Serializable.

Na rozdiel od getSuperclass() a getInterfaces(), ktoré vracajú objekty Class bez typových argumentov, môžu generické metódy poskytnúť ParameterizedType, pri rozhraniach ako prvok poľa. Pred volaním getActualTypeArguments() over typ pomocou instanceof ParameterizedType. Argumenty sú hodnoty Type: môžu predstavovať konkrétne triedy, vnorené parametrizované typy alebo typové premenné. Surový nadtyp, napríklad List bez argumentov, je reprezentovaný objektom Class.

Tieto metódy čítajú signatúry deklarácií, nie typové argumenty jednotlivých inštancií. Pre vymazávanie typov dáva new ArrayList<String>().getClass() tú istú triedu ako ArrayList.class: jej nadtrieda je AbstractList<E>, kde E je TypeVariable, nie String. Podtrieda deklarovaná s extends ArrayList<String> naopak zaznamenáva String vo vlastnej signatúre.

Obe metódy môžu vyvolať GenericSignatureFormatError pri neplatnom formáte signatúry, TypeNotPresentException, ak odkazovaný typ chýba, alebo MalformedParameterizedTypeException, ak parametrizovaný typ nemožno vytvoriť.

Príklady

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

Výsledok

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

`Names` deklaruje presne jedno priame rozhranie, preto príklad používa index `0`. Prvé dve kontroly načítajú `String` a `Integer` z deklarácie `Names`; tretia potvrdzuje, že argumentom nadtriedy bežnej `ArrayList` je typová premenná `E`.

Súvisiace lekcie

  • Java · Lekcia 36 · Stredne pokročilá · Verzia: 2

Zdroje