Wie man den generischen Typ zur Laufzeit?

Dies ist mein code:
Die ExecutorImp erstreckt AbstractExecutor dem extrahieren ausführen Logiken, deren Implementierer(ExecutorImp ist ein Fall),beim aufrufen der execute () - Methode ExecutorImp, es wird die Methode aufgerufen, in seinem Supertyp,aber der Supertyp (der AbstractExcutor) wissen sollten eine weitere Klasse, die Bindung an die Umsetzer(im Beispiel ist es der User-Klasse):

import java.lang.reflect.InvocationTargetException;
import java.util.ArrayList;

abstract class AbstractExecutor<E> {
    public void execute() throws Exception {
        ArrayList<E> list = new ArrayList<E>();
        //here I want to get the real type of 'E'
        Class cl = this.getClass().getTypeParameters()[0].getGenericDeclaration().getClass();
        Object o = cl.getConstructor(String.class).newInstance("Gate");
        list.add((E) o);
        System.out.println(format(list));
    }
    public abstract String format(ArrayList<E> list);
    public abstract String getType();
}

public class ExectorImp<E> extends AbstractExecutor<User> {
    @Override
    public String getType() {
        return "user";
    }
    @Override
    public String format(ArrayList<User> list) {
        StringBuffer sb = new StringBuffer();
        for (User u : list) {
            sb.append(u.toString() + " ");
        }
        return sb.toString();
    }
    public static void main(String[] args) throws Exception {
        new ExectorImp().execute();
    }
}
class User {
    String name;
    public User(String name) {
        this.name = name;
    }
}

SO, was ist das problem mit meinem Code?

InformationsquelleAutor hguser | 2010-10-15
  1. 14

    Es gibt einige Verwirrung hier. Aufgrund der type erasure kann man nicht bekommen, geben Sie die Informationen aus der Laufzeit parametrisierter Typ wie:

    Class<E> cls = E.getClass(); //Error.
E e = new E(); //Error.

    Allerdings erhalten Sie compile-Zeit parametrisierte geben Informationen aus der Klasse, Feld, Methode und Erklärung von ParameterizedType#getActualTypeArguments().

    abstract class AbstractExecutor<E> {

    public void execute() throws Exception {
        List<E> list = new ArrayList<E>();
        Class<E> cls = (Class<E>) ((ParameterizedType) getClass().getGenericSuperclass()).getActualTypeArguments()[0];
        E e = cls.getConstructor(String.class).newInstance("Gate");
        list.add(e);
        System.out.println(format(list));
    }

    //...
}

    Update: als ob diese empfehlenswert ist oder nicht, obwohl dies funktioniert, dies ist empfindlich auf Laufzeit-Probleme auf, wenn geringfügige änderungen in der Klassen-Deklaration auftreten. Sie als Entwickler sollten dokumentieren, ist es richtig. Als ganz andere alternative, die Sie machen können Verwendung von Polymorphismus.

    abstract class AbstractExecutor<E> {

    public void execute() throws Exception {
        List<E> list = new ArrayList<E>();
        E e = create("Gate");
        list.add(e);
        System.out.println(format(list));
    }

    public abstract E create(String name);

    //...
}

    und implementieren UserExecutor entsprechend.

    class UserExecutor extends AbstractExecutor<User> {

    @Override
    public User create(String name) {
        return new User(name);
    }

    //...
}
    InformationsquelleAutor BalusC
  2. 6

    Ich glaube, Sie sollten getActualTypeParameters; als getTypeParameters bezieht sich nicht auf das, was gebracht worden ist in Ihre aktuelle Instanziierung statt E, aber E selbst (um zu beschreiben, wie es ist begrenzt, etc.).

    Um die ParameterizedType Sie verwenden sollten getGenericSuperclass ersten.

    update: aber das oben beschriebene funktioniert nur, wenn das aktuelle Objekt ist abgeleitet von einer generischen Klasse mit dem generischen argument instanziiert, wie:

    class StringList extends ArrayList<String> {
    public Type whatsMyGenericType() {
        return ((ParameterizedType)getGenericSuperClass()).getActualTypeParameters()[0];
    }
}

    zurückkehren sollte String.class.

    • Nur um präzise zu sein: getGenericSuperclass() geben aussagekräftige Ergebnisse für Sie nur, wenn die Klasse nicht in eine generische Klasse, also: new LinkedList<Zeichenfolge>().getClass().getGenericSuperclass() nicht genug für Sie, aber: new LinkedList<Zeichenfolge>(){}.getClass().getGenericSuperclass() OK ist - den Unterschied bemerkt? Durch hinzufügen von {}, die ich erstellt Unterklasse von LinkedList.
    • stimmt, dann denke ich, es gibt keine Möglichkeit für ein Objekt zu ermitteln, wie es war nachdenklich erklärt, aber es könnte getan werden, "von außen" (mit Field.getGenericType() zum Beispiel)...
    InformationsquelleAutor fortran
  3. 2

    Ich glaube nicht, Sie könnte den generischen Typ zur Laufzeit. Der generische Typ ist eine Einschränkung gilt, dass zur compile-Zeit. Soweit ich mich erinnere, zur Laufzeit gibt es keinen Unterschied zwischen einem generischen Sammlung und eine Sammlung ohne einen generischen Typ.

    • Nicht ganz richtig: Lesen Sie die Lösung durch 'fortran' und mein Kommentar zu es.
    • He he, ich dachte das auch mal... Die Löschung bedeutet, dass zur compile-Zeit könnten Sie ignorieren die generische Beschränkungen wie bei der bytecode-Ausführung beider Instanzen ist die gleiche, aber die Informationen, wie die Instanzen deklariert wurden, gehalten wird.
    InformationsquelleAutor Seitaridis
  4. 1

    Übliche Vorgehensweise, um das problem zu beheben ist zu geringfügig ändern Sie den code. Definieren-Konstruktor in der Basisklasse annehmen Class<E> parameter. Weisen Sie diese parameter, um den internen Bereich.

    In der Unterklasse definieren-Konstruktor ohne Parameter und rufen super(User.class) von dort.

    Diese Weise werden Sie wissen, Klasse argument, ohne viel Abraum für die Kunden der Unterklassen.

    InformationsquelleAutor oiavorskyi
Schreibe einen Kommentar