Comment obtenir le type générique au moment de l'exécution?

C'est mon code:
Le ExecutorImp s'étend AbstractExecutor qui extrait de la même exécuter des logiques de ses exécutants(ExecutorImp est un cas),lors de l'appel de la méthode execute() de ExecutorImp, il va appeler la méthode dans son supertype,mais le supertype (le AbstractExcutor) devrait connaître une autre classe de liaison à l'opérateur(dans l'exemple, c'est l'Utilisateur de la classe):

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

ALORS, quel est le problème avec mes codes?

Peut-être que cette réponse peut vous aider avec votre problème. stackoverflow.com/questions/6624113/...

OriginalL'auteur hguser | 2010-10-15

Il y a une certaine confusion ici. En raison du type d'effacement, vous ne pouvez pas obtenir le type d'informations à partir de l'exécution paramétrée type:

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

Cependant, vous pouvez obtenir compile-time paramétrée informations de type de la classe, de champ et de déclaration de la méthode par 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));
    }

    //...
}

Mise à jour: si c'est recommandé ou pas, même si cela va fonctionner, c'est sensible à l'exécution des problèmes à chaque fois que des changements mineurs dans la déclaration de classe se produire. Vous, en tant que développeur doit documenter correctement. Comme un de complètement différent alternative, vous pouvez utiliser le polymorphisme.

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

    //...
}

et de mettre en œuvre UserExecutor en conséquence.

class UserExecutor extends AbstractExecutor<User> {

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

    //...
}

Merci beaucoup, et merci pour tous les gars dans cette page. BalusC réponse est ce que je voulais.Cependant je me demande si mon code est recommandé? Voici mon applaction contexte:forums.oracle.com/forums/message.jspa?messageID=7006003#7006003

OriginalL'auteur BalusC

6

Je pense que vous devriez utiliser getActualTypeParameters; comme getTypeParameters ne fait pas référence à ce qui a été mis au courant de votre instanciation en place de E, mais à E lui-même (pour décrire comment est-il borné, etc.).

Afin d'obtenir le ParameterizedType vous devez utiliser getGenericSuperclass premier.

mise à jour: mais le ci-dessus ne fonctionne que si l'objet courant est dérivé d'une classe générique avec l'argument générique instancié, comme:
```
class StringList extends ArrayList<String> {
    public Type whatsMyGenericType() {
        return ((ParameterizedType)getGenericSuperClass()).getActualTypeParameters()[0];
    }
}
```
doit retourner String.class.

Juste pour être précis: getGenericSuperclass() donnera des résultats significatifs pour vous seulement si la classe n'est pas une classe générique, donc: new LinkedList<String>().getClass().getGenericSuperclass() ne sera pas suffisant pour vous, mais: new LinkedList<String>(){}.getClass().getGenericSuperclass() est OK - remarqué la différence? En ajoutant les {} j'ai créé sous-classe de la LinkedList.
vrai, alors je pense qu'il y a aucun moyen pour un objet à détecter la façon dont il a été reflectively déclaré, mais il pourrait être fait "de l'extérieur" (à l'aide de Field.getGenericType(), par exemple)...

OriginalL'auteur fortran
2

Je ne pense pas que vous pourriez obtenir le générique de type à l'exécution. Le type générique est une restriction qui s'applique au moment de la compilation. Comme je me souviens, lors de l'exécution il n'y a pas de différence entre une collection générique et une collection sans un type générique.

Pas tout à fait vrai: la lecture de la solution par "fortran" et mon commentaire.
Il a il a, je pensais que une fois de trop... L'effacement signifie qu'au moment de la compilation, vous pouvez ignorer le générique restrictions que le bytecode de l'exécution des deux cas est le même, mais les informations sur la façon dont les cas ont été déclarés est conservé.

OriginalL'auteur Seitaridis
1

Approche habituelle pour résoudre le problème est de modifier légèrement le code. Définir le constructeur de la classe de base d'accepter Class<E> paramètre. Attribuez à ce paramètre de champ interne.

Sur le sous-classe de définir constructeur sans paramètres et appel super(User.class) à partir de là.

Cette façon, vous saurez classe de l'argument sans trop surcharger pour les clients des sous-classes.

OriginalL'auteur Oleg Iavorskyi

Vous devez vous connecter pour publier un commentaire.