Ruft den Typ eines generischen Parameters in Java mit Reflektion ab

Ist es möglich, den Typ eines generischen Parameters abzurufen?

Ein Beispiel:

public final class Voodoo {
    public static void chill(List<?> aListWithTypeSpiderMan) {
        // Here I'd like to get the Class-Object 'SpiderMan'
        Class typeOfTheList = ???;
    }

    public static void main(String... args) {
        chill(new ArrayList<SpiderMan>());
    }
}

Ein Konstrukt, über das ich einmal gestolpert bin, sah aus wie

Class<T> persistentClass = (Class<T>)
   ((ParameterizedType)getClass().getGenericSuperclass())
      .getActualTypeArguments()[0];

Es scheint also eine Reflexionsmagie zu geben, die ich leider nicht ganz verstehe ... Entschuldigung.

Ich möchte versuchen, die Antwort von @DerMike aufzuschlüsseln, um Folgendes zu erklären:

Erstens bedeutet das Löschen des Typs nicht, dass das JDK eliminiert Typinformationen zur Laufzeit. Es ist eine Methode, mit der die Typprüfung zur Kompilierungszeit und die Laufzeitkompatibilität in derselben Sprache koexistieren können. Wie dieser Codeblock impliziert, behält das JDK die gelöschten Typinformationen bei - es ist nur nicht mit überprüften Casts und Sachen verbunden.

Zweitens liefert dies generische Typinformationen für eine generische Klasse genau eine Ebene höher als die Hierarchie des zu überprüfenden konkreten Typs - dh eine abstrakte übergeordnete Klasse mit generischen Typparametern kann die konkreten Typen finden, die ihren Typparametern für eine konkrete Implementierung von sich selbst entsprechen das erbt direkt davon. Wenn diese Klasse nicht abstrakt und instanziiert wäre oder die konkrete Implementierung zwei Ebenen tiefer wäre, würde dies nicht funktionieren (obwohl ein wenig Jimmying dazu führen könnte, dass sie auf eine vorgegebene Anzahl von Ebenen über eine oder bis zur niedrigsten Klasse angewendet wird mit X generischen Typparametern usw.).

Wie auch immer, weiter zur Erklärung. Hier ist noch einmal der Code, der zur leichteren Bezugnahme in Zeilen unterteilt ist:

1 # Klasse genericParameter0OfThisClass = 
2 # (Klasse)
3 # ((ParameterizedType)
4 # getClass ()
5 # .getGenericSuperclass ())
6 # .getActualTypeArguments () [0];

Sei 'wir' die abstrakte Klasse mit generischen Typen, die diesen Code enthält. Lesen Sie dies grob von innen nach außen:

• Zeile 4 ruft die aktuelle Klasseninstanz der konkreten Klasse ab. Dies identifiziert den konkreten Typ unseres unmittelbaren Nachkommen.
• Zeile 5 erhält den Supertyp dieser Klasse als Typ. Das sind wir. Da wir ein parametrischer Typ sind, können wir uns sicher in ParameterizedType (Zeile 3) umwandeln. Der Schlüssel ist, dass Java, wenn es dieses Type-Objekt bestimmt, die im Kind vorhandenen Typinformationen verwendet, um Typinformationen unseren Typparametern in der neuen ParameterizedType-Instanz zuzuordnen. Jetzt können wir auf konkrete Typen für unsere Generika zugreifen.
• Zeile 6 ruft das Array von Typen ab, die unseren Generika zugeordnet sind, in der Reihenfolge, wie sie im Klassencode deklariert ist. In diesem Beispiel ziehen wir den ersten Parameter heraus. Dies kommt als Typ zurück.
• Zeile 2 wirft den endgültigen Typ, der an eine Klasse zurückgegeben wurde. Dies ist sicher, da wir wissen, welche Typen unsere generischen Typparameter annehmen können, und bestätigen können, dass es sich bei allen um Klassen handelt (ich bin mir nicht sicher, wie man in Java einen generischen Parameter ohne Klasseninstanz abrufen würde damit verbunden).

... und das war's auch schon. Wir übertragen also Typinformationen aus unserer eigenen konkreten Implementierung zurück in uns selbst und verwenden sie, um auf ein Klassenhandle zuzugreifen. Wir könnten getGenericSuperclass () verdoppeln und zwei Ebenen durchlaufen oder getGenericSuperclass () eliminieren und Werte für uns als konkreten Typ erhalten (Einschränkung: Ich habe diese Szenarien nicht getestet, sie sind noch nicht für mich aufgetaucht).

Es wird schwierig, wenn Ihre konkreten Kinder eine beliebige Anzahl von Sprüngen entfernt sind oder wenn Sie konkret und nicht endgültig sind, und besonders schwierig, wenn Sie erwarten, dass eines Ihrer (unterschiedlich tiefen) Kinder seine eigenen Generika hat. Normalerweise können Sie diese Überlegungen jedoch berücksichtigen, sodass Sie den größten Teil des Weges zurücklegen können.

Hoffe das hat jemandem geholfen! Ich erkenne, dass dieser Beitrag uralt ist. Ich werde diese Erklärung wahrscheinlich abschneiden und für andere Fragen aufbewahren.

Eigentlich habe ich das zum Laufen gebracht. Betrachten Sie das folgende Snippet:

Method m;
Type[] genericParameterTypes = m.getGenericParameterTypes();
for (int i = 0; i < genericParameterTypes.length; i++) {
     if( genericParameterTypes[i] instanceof ParameterizedType ) {
                Type[] parameters = ((ParameterizedType)genericParameterTypes[i]).getActualTypeArguments();
//parameters[0] contains java.lang.String for method like "method(List<String> value)"

     }
 }

Ich benutze JDK 1.6

Es gibt tatsächlich eine Lösung, indem der Trick "anonyme Klasse" und die Ideen aus den Super Type Tokens angewendet werden :

public final class Voodoo {
    public static void chill(final List<?> aListWithSomeType) {
        // Here I'd like to get the Class-Object 'SpiderMan'
        System.out.println(aListWithSomeType.getClass().getGenericSuperclass());
        System.out.println(((ParameterizedType) aListWithSomeType
            .getClass()
            .getGenericSuperclass()).getActualTypeArguments()[0]);
    }
    public static void main(String... args) {
        chill(new ArrayList<SpiderMan>() {});
    }
}
class SpiderMan {
}

Der Trick liegt in der Schaffung einer anonymen Klasse , new ArrayList<SpiderMan>() {}an der Stelle des ursprünglichen (einfach) new ArrayList<SpiderMan>(). Die Verwendung einer anoymischen Klasse (falls möglich) stellt sicher, dass der Compiler Informationen über das Typargument behält SpiderMan, das dem Typparameter gegeben wurde List<?>. Voilà!

Aufgrund der Typlöschung besteht die einzige Möglichkeit, den Typ der Liste zu ermitteln, darin, den Typ als Parameter an die Methode zu übergeben:

public class Main {

    public static void main(String[] args) {
        doStuff(new LinkedList<String>(), String.class);

    }

    public static <E> void doStuff(List<E> list, Class<E> clazz) {

    }

}

Anhang zur Antwort von @ DerMike zum Abrufen des generischen Parameters einer parametrisierten Schnittstelle (mithilfe der Methode #getGenericInterfaces () in einer Java-8-Standardmethode, um Doppelarbeit zu vermeiden):

import java.lang.reflect.ParameterizedType; 

public class ParametrizedStuff {

@SuppressWarnings("unchecked")
interface Awesomable<T> {
    default Class<T> parameterizedType() {
        return (Class<T>) ((ParameterizedType)
        this.getClass().getGenericInterfaces()[0])
            .getActualTypeArguments()[0];
    }
}

static class Beer {};
static class EstrellaGalicia implements Awesomable<Beer> {};

public static void main(String[] args) {
    System.out.println("Type is: " + new EstrellaGalicia().parameterizedType());
    // --> Type is: ParameterizedStuff$Beer
}

Nein, das ist nicht möglich. Aufgrund von Abwärtskompatibilitätsproblemen basieren die Generika von Java auf der Löschung von Typen , dh zur Laufzeit. Sie haben lediglich ein nicht generisches ListObjekt. Es gibt einige Informationen zu Typparametern zur Laufzeit, diese befinden sich jedoch in Klassendefinitionen (dh Sie können fragen, welchen generischen Typ die Definition dieses Felds verwendet? ), Nicht in Objektinstanzen.

Wie von @bertolami hervorgehoben, ist es uns nicht möglich, einen Variablentyp zu erhalten und seinen zukünftigen Wert (den Inhalt der Variablen typeOfList) abzurufen.

Trotzdem können Sie die Klasse wie folgt als Parameter übergeben:

public final class voodoo {
    public static void chill(List<T> aListWithTypeSpiderMan, Class<T> clazz) {
        // Here I'd like to get the Class-Object 'SpiderMan'
        Class typeOfTheList = clazz;
    }

    public static void main(String... args) {
        chill(new List<SpiderMan>(), Spiderman.class );
    }
}

Dies ist mehr oder weniger das, was Google tut, wenn Sie eine Klassenvariable an den Konstruktor von ActivityInstrumentationTestCase2 übergeben müssen .

Nein, das ist nicht möglich.

Sie können einen generischen Feldtyp erhalten, wenn eine Klasse die einzige Ausnahme von dieser Regel darstellt, und selbst das ist ein kleiner Hack.

Ein Beispiel hierfür finden Sie unter Kennen des generischen Typs in Java .

Sie können den Typ eines generischen Parameters mit Reflexion wie in diesem Beispiel erhalten, das ich hier gefunden habe :

import java.lang.reflect.ParameterizedType;
import java.lang.reflect.Type;

public class Home<E> {
    @SuppressWarnings ("unchecked")
    public Class<E> getTypeParameterClass(){
        Type type = getClass().getGenericSuperclass();
        ParameterizedType paramType = (ParameterizedType) type;
        return (Class<E>) paramType.getActualTypeArguments()[0];
    }

    private static class StringHome extends Home<String>{}
    private static class StringBuilderHome extends Home<StringBuilder>{}
    private static class StringBufferHome extends Home<StringBuffer>{}   

    /**
     * This prints "String", "StringBuilder" and "StringBuffer"
     */
    public static void main(String[] args) throws InstantiationException, IllegalAccessException {
        Object object0 = new StringHome().getTypeParameterClass().newInstance();
        Object object1 = new StringBuilderHome().getTypeParameterClass().newInstance();
        Object object2 = new StringBufferHome().getTypeParameterClass().newInstance();
        System.out.println(object0.getClass().getSimpleName());
        System.out.println(object1.getClass().getSimpleName());
        System.out.println(object2.getClass().getSimpleName());
    }
}

Die schnelle Antwort auf die Frage lautet: Nein, das können Sie nicht, da der generische Java-Typ gelöscht wird.

Die längere Antwort wäre, wenn Sie Ihre Liste wie folgt erstellt haben:

new ArrayList<SpideMan>(){}

In diesem Fall bleibt der generische Typ in der generischen Oberklasse der neuen anonymen Klasse oben erhalten.

Nicht, dass ich dies mit Listen empfehlen würde, aber es ist eine Listener-Implementierung:

new Listener<Type>() { public void doSomething(Type t){...}}

Und da sich die Extrapolation der generischen Typen von Superklassen und Superschnittstellen zwischen JVMs ändert, ist die generische Lösung nicht so einfach, wie einige Antworten vermuten lassen.

Hier ist jetzt habe ich es getan.

Dies ist unmöglich, da Generika in Java nur zur Kompilierungszeit berücksichtigt werden. Somit sind die Java-Generika nur eine Art Vorprozessor. Sie können jedoch die tatsächliche Klasse der Mitglieder der Liste abrufen.

Ich habe dies für Methoden codiert, die erwarten, dass sie akzeptiert oder zurückgegeben werden Iterable<?...>. Hier ist der Code:

/**
 * Assuming the given method returns or takes an Iterable<T>, this determines the type T.
 * T may or may not extend WindupVertexFrame.
 */
private static Class typeOfIterable(Method method, boolean setter)
{
    Type type;
    if (setter) {
        Type[] types = method.getGenericParameterTypes();
        // The first parameter to the method expected to be Iterable<...> .
        if (types.length == 0)
            throw new IllegalArgumentException("Given method has 0 params: " + method);
        type = types[0];
    }
    else {
        type = method.getGenericReturnType();
    }

    // Now get the parametrized type of the generic.
    if (!(type instanceof ParameterizedType))
        throw new IllegalArgumentException("Given method's 1st param type is not parametrized generic: " + method);
    ParameterizedType pType = (ParameterizedType) type;
    final Type[] actualArgs = pType.getActualTypeArguments();
    if (actualArgs.length == 0)
        throw new IllegalArgumentException("Given method's 1st param type is not parametrized generic: " + method);

    Type t = actualArgs[0];
    if (t instanceof Class)
        return (Class<?>) t;

    if (t instanceof TypeVariable){
        TypeVariable tv =  (TypeVariable) actualArgs[0];
        AnnotatedType[] annotatedBounds = tv.getAnnotatedBounds();///
        GenericDeclaration genericDeclaration = tv.getGenericDeclaration();///
        return (Class) tv.getAnnotatedBounds()[0].getType();
    }

    throw new IllegalArgumentException("Unknown kind of type: " + t.getTypeName());
}

Sie können keinen generischen Parameter aus einer Variablen abrufen. Sie können jedoch aus einer Methode oder Felddeklaration:

Method method = getClass().getDeclaredMethod("chill", List.class);
Type[] params = method.getGenericParameterTypes();
ParameterizedType firstParam = (ParameterizedType) params[0];
Type[] paramsOfFirstGeneric = firstParam.getActualTypeArguments();

Nur für mich war das Lesen dieses Codeausschnitts schwierig, ich habe es nur in zwei lesbare Zeilen unterteilt:

// assuming that the Generic Type parameter is of type "T"
ParameterizedType p = (ParameterizedType) getClass().getGenericSuperclass();
Class<T> c =(Class<T>)p.getActualTypeArguments()[0];

Ich wollte eine Instanz des Type-Parameters erstellen, ohne Parameter für meine Methode zu haben:

publc T getNewTypeInstance(){
    ParameterizedType p = (ParameterizedType) getClass().getGenericSuperclass();
    Class<T> c =(Class<T>)p.getActualTypeArguments()[0];

    // for me i wanted to get the type to create an instance
    // from the no-args default constructor
    T t = null;
    try{
        t = c.newInstance();
    }catch(Exception e){
        // no default constructor available
    }
    return t;
}

Hier ist ein weiterer Trick. Verwenden Sie ein generisches Vararg-Array

import java.util.ArrayList;

class TypedArrayList<E> extends ArrayList<E>
{
    @SafeVarargs
    public TypedArrayList (E... typeInfo)
    {
        // Get generic type at runtime ...
        System.out.println (typeInfo.getClass().getComponentType().getTypeName());
    }
}

public class GenericTest
{
    public static void main (String[] args)
    {
        // No need to supply the dummy argument
        ArrayList<Integer> ar1 = new TypedArrayList<> ();
        ArrayList<String> ar2 = new TypedArrayList<> ();
        ArrayList<?> ar3 = new TypedArrayList<> ();
    }
}

Mir ist aufgefallen, dass sich viele Menschen zur getGenericSuperclass()Lösung neigen:

class RootGeneric<T> {
  public Class<T> persistentClass = (Class<T>)
    ((ParameterizedType)getClass().getGenericSuperclass())
      .getActualTypeArguments()[0];
}

Diese Lösung ist jedoch fehleranfällig. Es wird nicht richtig funktionieren, wenn die Nachkommen Generika enthalten. Bedenken Sie:

class Foo<S> extends RootGeneric<Integer> {}

class Bar extends Foo<Double> {}

Welcher Typ wird Bar.persistentClasshaben? Class<Integer>? Nein, das wird es sein Class<Double>. Dies geschieht, weil getClass()immer die oberste Klasse zurückgegeben wird, was Barin diesem Fall der Fall ist, und die generische Superklasse ist Foo<Double>. Daher wird der Argumenttyp sein Double.

Wenn Sie eine zuverlässige Lösung benötigen, die nicht fehlschlägt, kann ich zwei vorschlagen.

1. Verwenden Sie Guava. Es hat eine Klasse, die genau für diesen Zweck gemacht wurde : com.google.common.reflect.TypeToken. Es behandelt alle Eckkoffer einwandfrei und bietet einige weitere nette Funktionen. Der Nachteil ist eine zusätzliche Abhängigkeit. Wenn Sie diese Klasse verwendet haben, sieht Ihr Code einfach und klar aus:

class RootGeneric<T> {
  @SuppressWarnings("unchecked")
  public final Class<T> persistentClass = (Class<T>) (new TypeToken<T>(getClass()) {}.getType());
}

2. Verwenden Sie die unten stehende benutzerdefinierte Methode. Es implementiert eine erheblich vereinfachte Logik ähnlich der oben erwähnten Guava-Klasse. Ich würde jedoch nicht garantieren, dass es fehleranfällig ist. Es löst jedoch das Problem mit den generischen Nachkommen.

abstract class RootGeneric<T> {
  @SuppressWarnings("unchecked")
  private Class<T> getTypeOfT() {
    Class<T> type = null;
    Class<?> iter = getClass();
    while (iter.getSuperclass() != null) {
      Class<?> next = iter.getSuperclass();
      if (next != null && next.isAssignableFrom(RootGeneric.class)) {
        type =
            (Class<T>)
                ((ParameterizedType) iter.getGenericSuperclass()).getActualTypeArguments()[0];
        break;
      }
      iter = next;
    }
    if (type == null) {
      throw new ClassCastException("Cannot determine type of T");
    }
    return type;
  }
}

Verwenden:

Class<?> typeOfTheList = aListWithTypeSpiderMan.toArray().getClass().getComponentType();