Instancier un type générique en java

Question

Je voudrais créer un objet de type générique en java. Veuillez me suggérer comment je peux y parvenir.

Note : Ceci peut sembler être un problème générique trivial. Mais je parie qu'il ne l'est pas. :)

supposons que j'aie la déclaration de classe comme :

public class Abc<T> {
    public T getInstanceOfT() {
       // I want to create an instance of T and return the same.
    }
}

Answer 1

public class Abc<T> {
    public T getInstanceOfT(Class<T> aClass) {
       return aClass.newInstance();
    }
}

Vous devrez ajouter la gestion des exceptions.

Vous devez transmettre le type réel au moment de l'exécution, car il ne fait pas partie du code octet après la compilation, et il n'y a donc aucun moyen de le connaître sans le fournir explicitement.

Answer 2

Dans le code que vous avez posté, il est impossible de créer une instance de T puisque vous ne savez pas de quel type il s'agit :

public class Abc<T>
{
       public T getInstanceOfT()
       {
           // There is no way to create an instance of T here
           // since we don't know its type
       }
} 

Bien sûr, c'est possible si vous avez une référence à Class<T> y T a un constructeur par défaut, il suffit d'appeler newInstance() sur le Class objet.

Si vous sous-classez Abc<T> vous pouvez même contourner le problème de l'effacement des types et vous n'aurez pas à passer d'informations. Class<T> références autour :

import java.lang.reflect.ParameterizedType;

public class Abc<T>
{
    T getInstanceOfT()
    {
        ParameterizedType superClass = (ParameterizedType) getClass().getGenericSuperclass();
        Class<T> type = (Class<T>) superClass.getActualTypeArguments()[0];
        try
        {
            return type.newInstance();
        }
        catch (Exception e)
        {
            // Oops, no default constructor
            throw new RuntimeException(e);
        }
    }

    public static void main(String[] args)
    {
        String instance = new SubClass().getInstanceOfT();
        System.out.println(instance.getClass());
    }
}

class SubClass
    extends Abc<String>
{
}

Answer 3

Ce que tu as écrit n'a aucun sens, génériques en Java sont destinés à ajouter la fonctionnalité de polymorphisme paramétrique aux objets.

Qu'est-ce que cela signifie ? Ça veut dire que tu veux garder un peu variables de type de vos classes indécises, pour pouvoir utiliser vos classes avec de nombreux types différents.

Mais votre variable de type T est un attribut qui est résolu au moment de l'exécution, le compilateur Java compilera votre classe en prouvant la sécurité de type sans essayer de savoir quel type d'objet est T il est donc impossible qu'il vous laisse utiliser une variable de type dans une méthode statique. Le type est associé à une instance d'exécution de l'objet tandis que le type est associé à une instance d'exécution de l'objet. public void static main(..) est associé à la définition de la classe et à cette portée T ne veut rien dire.

Si vous voulez utiliser un variable de type à l'intérieur d'une méthode statique, vous devez déclarer la méthode comme générique (ceci parce que, comme expliqué variables de type d'une classe modèle sont liées à son instance d'exécution ), pas la classe :

class SandBox
{
  public static <T> void myMethod()
  {
     T foobar;
  }
}

cela fonctionne, mais bien sûr pas avec main puisqu'il n'y a aucun moyen de l'appeler de manière générique.

EDITAR : Le problème est qu'à cause de effacement de type une seule classe générique est compilée et transmise à la JVM. Le vérificateur de type vérifie simplement si le code est sûr, puis, comme il l'a prouvé, chaque type de information générique est rejetée.

Pour instancier T vous devez connaître le type de T mais il peut s'agir de plusieurs types en même temps. Une solution qui ne nécessite qu'un minimum de réflexion consiste donc à utiliser Class<T> pour instancier de nouveaux objets :

public class SandBox<T>
{
    Class<T> reference;

    SandBox(Class<T> classRef)
    {
        reference = classRef;
    }

    public T getNewInstance()
    {
        try
        {
            return reference.newInstance();
        }
        catch (Exception e)
        {
            e.printStackTrace();
        }

        return null;
    }

    public static void main(String[] args)
    {
        SandBox<String> t = new SandBox<String>(String.class);

        System.out.println(t.getNewInstance().getClass().getName());
    }
}

Bien sûr, cela implique que le type que vous voulez instancier :

• n'est pas un type primitif
• il a un constructeur par défaut

Pour utiliser d'autres types de constructeurs, vous devez approfondir la réflexion.

Answer 4

Le seul moyen de le faire fonctionner est d'utiliser Génériques réifiés . Et cela n'est pas pris en charge par Java (pas encore ? il l'était prévu pour Java 7, mais a été repoussé). En C# par exemple, il est supporté en supposant que T a un par défaut constructeur. Vous pouvez même obtenir le type d'exécution en typeof(T) et obtenir les constructeurs par Type.GetConstructor() . Je ne fais pas de C# donc la syntaxe peut être invalide, mais cela ressemble grossièrement à ceci :

public class Foo<T> where T:new() {
    public void foo() {
        T t = new T();
    }
}

La meilleure solution de contournement en Java est de passer un fichier Class<T> comme argument de méthode à la place, comme plusieurs réponses l'ont déjà souligné.

Answer 5

Vous ne semblez pas comprendre le fonctionnement des génériques. Vous devriez peut-être regarder http://java.sun.com/j2se/1.5.0/docs/guide/language/generics.html En gros, ce que vous pourrait est quelque chose comme

public class Abc<T>
{
  T someGenericThing;
  public Abc(){}
  public T getSomeGenericThing()
  {
     return someGenericThing;
  }

  public static void main(String[] args)
  {
     // create an instance of "Abc of String"
        Abc<String> stringAbc = new Abc<String>();
        String test = stringAbc.getSomeGenericThing();
  }

}