puis-je instancier de manière réfléchie un type générique dans Java?

Est-il possible de reflectively instancier un type générique en Java? À l'aide de la technique décrite ici j'obtiens une erreur parce que la classe jetons ne peuvent pas être générique. Prenons l'exemple ci-dessous. Je veux instancier certains sous-classe de Créateur qui implémente Créateur. Le nom de la classe réelle est passé en argument de ligne de commande. L'idée est d'être capable de spécifier une mise en œuvre du Créateur au moment de l'exécution. Est-il une autre façon d'accomplir ce que je suis en train de faire ici?

public interface Creator<T> {
    T create();
}
public class StringCreator implements Creator<String> {
    public String create() { return new String(); }
}
public class FancyStringCreator implements Creator<String> {
    public String create() { return new StringBuffer().toString(); }
}
public static void main(String[] args) throws Exception {
    Class<?> someClass = Class.forName(args[0]);
    /*ERROR*/Class<? extends Creator<String>> creatorClass = someClass.asSubclass(Creator.class);
    Constructor<? extends Creator<String>> creatorCtor = creatorClass.getConstructor((Class<?>[]) null);
    Creator<String> creator = creatorCtor.newInstance((Object[]) null);
}

Edit: j'aime Marcus' approche la plus simple et pragmatique, et ce sans contourner l'ensemble des génériques chose. Je peux l'utiliser dans ma situation parce que je peux préciser que la classe a réussi doit être une sous-classe de StringCreator. Mais comme Ericsson, a souligné le générique de l'information est encore là, au niveau du type, tout simplement pas au niveau d'exécution de sorte qu'il est encore possible de reflectively examiner si une classe implémente le bon type générique.

source d'informationauteur sk.

  1. 7

    Le générique de l'information est perdue dans l'exécution. Il n'y a pas d'exécution équivalent d'un Créateur<String>.classe. Vous pouvez créer un type entre le Créateur et la StringCreator qui fixe le type générique:

    public interface Creator<T> {
        T create();
}
public interface StringCreator extends Creator<String> { }
public class StringCreatorImpl implements StringCreator  {
        public String create() { return new String(); }
}
public class FancyStringCreator implements StringCreator  {
        public String create() { return new StringBuffer().toString(); }
}
public static void main(String[] args) throws Exception {
        Class<?> someClass = Class.forName(args[0]);
        Class<? extends StringCreator> creatorClass = someClass.asSubclass(StringCreator.class);
        Constructor<? extends StringCreator> creatorCtor = creatorClass.getConstructor((Class<?>[]) null);
        Creator<String> creator = creatorCtor.newInstance((Object[]) null);
}

    Mais bien sûr, vous perdez un peu de souplesse, parce que vous ne pouvez pas utiliser les éléments suivants créateur de la classe:

    public class AnotherCreator implements Creator<String> {
    public String create() { return ""; }
}
  2. 4

    Cela va faire ce que vous essayez de faire tout en fournissant le type de sécurité. Il n'y a aucun moyen d'éviter une décoché l'avertissement, mais le type de vérification fait ici justifie sa suppression.

      public static void main(String[] args)
throws Exception
{
Class<? extends Creator<String>> clz = load(argv[0], String.class);
Constructor<? extends Creator<String>> ctor = clz.getConstructor();
Creator<String> creator = ctor.newInstance();
System.out.println(creator.create());
}
public static <T> Class<? extends Creator<T>> load(String fqcn, Class<T> type)
throws ClassNotFoundException
{
Class<?> any = Class.forName(fqcn);
for (Class<?> clz = any; clz != null; clz = clz.getSuperclass()) {
for (Object ifc : clz.getGenericInterfaces()) {
if (ifc instanceof ParameterizedType) {
ParameterizedType pType = (ParameterizedType) ifc;
if (Creator.class.equals(pType.getRawType())) {
if (!pType.getActualTypeArguments()[0].equals(type))
throw new ClassCastException("Class implements " + pType);
/* We've done the necessary checks to show that this is safe. */
@SuppressWarnings("unchecked")
Class<? extends Creator<T>> creator = (Class<? extends Creator<T>>) any;
return creator;
}
}
}
}
throw new ClassCastException(fqcn + " does not implement Creator<String>");
}

    La principale restriction que vous avez à respecter est qu'une classe dans la hiérarchie devez spécifier le paramètre de type. Par exemple class MyCreator implements Creator<String>. Vous ne pouvez pas l'utiliser avec class GenericCreator<T> implements Creator<T>.

    Il ne dispose pas actuellement de traiter le cas valide lorsque vous créez une nouvelle interface interface StringCreatorIfc extends Creator<String>et ont une classe à mettre en œuvre. Il pourrait être amélioré pour le faire, mais je vais laisser ça comme un exercice pour ceux qui sont enclins.

  3. 3

    Vous n'avez pas besoin de cette ligne. Ni avez-vous besoin le constructeur que vous êtes tout simplement à l'aide de la valeur par défaut. Il vous suffit d'instancier la classe:

    public static void main(String[] args) throws Exception {
Class<?> someClass = Class.forName(args[0]);
Creator<String> creator = (Creator<String>) someClass.newInstance();
}

    Si vous insistez, vous ne serez en mesure d'obtenir à mi-chemin:

    public static void main(String[] args) throws Exception {
Class<?> someClass = Class.forName(args[0]);
Class<? extends Creator> creatorClass = someClass.asSubclass(Creator.class);
Constructor<? extends Creator> creatorCtor = creatorClass.getConstructor((Class<?>[]) null);
Creator<String> creator = (Creator<String>) creatorCtor.newInstance((Object[]) null);
}
  4. -1

    Pas très bien pourquoi vous êtes à l'utilisation de génériques ici.

    L'instanciation de l'objet à l'aide de la réflexion suggère un usage général, mais sans doute vous allez appeler create à un certain point, et affecter le résultat à une Stringsinon pourquoi utiliser les génériques de contrôler le type de retour.

    Mais si vous avez écrit la suite de la mise en œuvre du Créateur:

    public class IntegerCreator implements Creator<Integer> 
{
public Integer create() 
{ 
...
}
}

    Et l'a adopté en tant qu'argument, vous obtiendrez une ClassCastException lors de l'appel de create et l'affectation du résultat.