Comment faire MyClass & lt; String & gt; .class en Java?

Comment pouvez appeler public <T> T doit(Class<T> clazz); à l'aide de MyClass<String>.class comme clazz où je ne peux pas instancier ou étendre MyClass.

EDIT: David Winslow " et " bmargulies les réponses sont correctes (MyClass<String>) doit(MyClass.class); travaille pour la question d'origine, MAIS étonnamment, lorsque la méthode renvoie dire MyClass<T> au lieu de T casting ne compilera pas.

Edit: j'ai remplacé Liste avec MyClass et ajout de la condition à ma question initiale.

source d'informationauteur Ali Shakiba

generics java

13

Utilisation List.class. En raison de type d'effacement les paramètres de type de classes Java sont entièrement au moment de la compilation, la construction, même si List<String>.class était une erreur de syntaxe, il serait le exactement la même classe comme List<Date>.classetc. Depuis la réflexion est, par nature, un runtime chose, il n'a pas bien avec des paramètres de type (tel que mis en œuvre en Java).

Si vous souhaitez utiliser la Classe de l'objet (par exemple) instancier une nouvelle instance de Liste, vous pouvez convertir le résultat de que l'opération de le paramètre de type.
```
List<String> list = (List<String>)(ArrayList.class.newInstance());
```
4

J'ai vu les mêmes questions posées à plusieurs reprises, par exemple
L'acquisition de la classe générique type

Il existe des raisons légitimes pour construire statique des types génériques. Dans op' cas, il aimerait sans doute
```
MyClass<String> result = doit(MyClass<String>.class);
```
Sans la syntaxe de la langue de support, le casting est la bonne façon de procéder. Si cela est nécessaire, assez souvent, le casting devrait être mis dans une méthode, comme
```
public class MyClass<T>
{
    @SuppressWarnings("unchecked")
    //may need a better method name
    static public <T2> Class<MyClass<T2>> of(Class<T2> tClass)
    {
        return (Class<MyClass<T2>>)(Class<?>)(MyClass.class);
    }
}

MyClass<String> result = doit(MyClass.of(String.class)); //no warning
```
Nous pouvons supprimer l'avertissement sur que la seule méthode, assurez-vous que le casting est sûr. Aucun appel ne pourra pas voir l'avertissement.

C'est tout moment de la compilation coulée de jeu. Lors de l'exécution de tous les paramètres de type sont effacés, et vraiment que le nu de la classe de l'objet est passé autour. Le of méthode la plus susceptible d'être optimisé, pour la JVM de la dernière ligne n'est rien, mais
```
MyClass result = doit(MyClass.class)
```
Il y a aussi des moments où à runtime nous avons besoin d'une complète MyClass<String> type. Un ParameterizedType objet doit être obtenue pour représenter MyClass<String>.

Lorsque les deux critères sont combinés ensemble, c'est, nous avons besoin d'un moment de la compilation, au sujet de l'expression MyClass et String à évaluer lors de l'exécution d'un ParameterizedType
```
ParameterizedType type_MyClass_String = ???? MyClass ?? String ???
```
Il y a une technique faisant appel à un anonyme sous-classe de MyClass<String>
```
ParameterizedType type_MyClass_String = superTypeOf( new MyClass<String>(){} );
```
que je trouve assez dérangeant.
2

Voir http://jackson.codehaus.org/1.7.0/javadoc/org/codehaus/jackson/type/TypeReference.html et les références qu'il fait référence pour une analyse détaillée des questions sur les génériques.

la ligne de fond est que, si vous voulez vraiment travailler avec les types génériques de cette façon, vous devez cesser d'utiliser Class et commencer à utiliser Type et de ses sous-classes.

Contrairement à votre commentaire sur une autre réponse, vous pouvez écrire List<List<String>> obj = (List<List<String>>) doit(List.class);vous ne pouvez tout simplement pas éviter un avertissement lorsque vous l'écrivez.
1

Car, après une mise à jour de votre question ne semble pas être l'exacte dupliquer:

Vous devez appeler getClass() sur une instance de MyClass. Vaut mieux avoir un mannequin statique dernière instance, quelque part:
```
public static final MyClass INSTANCE = new MyClass();
...
return (Class<MyClass<String>>) instance.getClass();
```
0

T correspond à Listde sorte que toute référence à String générique paramètre de List n'est pas pertinent.
-1

Comment faire MyClass<String>.class dans
Java?

Vous ne pouvez pas.

Génériques en Java, le type d'utilisation de l'effacement; le type de la paramétrées argument est appliqué lors de la compilation, mais il est perdu après compilation. La résultante de byte code pour une instance d'une classe générique ne contient aucun moment de l'exécution des méta-données sur ses arguments que ce soit.

Comme il est maintenant, c'est juste pas possible, une grande langue de conception bourde de l'OMI.

Vous devez vous connecter pour publier un commentaire.

Vous ne pouvez pas.