Java génériques type d'effacement: quand et ce qui se passe?

Le compilateur est responsable de comprendre les Génériques au moment de la compilation. Le compilateur est également responsable de jeter cette "compréhension" des classes génériques, dans un processus que nous appelons type d'effacement. Tout se passe au moment de la compilation.

Remarque: Contrairement aux croyances de la majorité des développeurs Java, il est possible de conserver le type de compilation de l'information et de récupérer cette information au moment de l'exécution, malgré un très limitées. En d'autres termes: Java fournit réifiée génériques en très peu de.

Sur le type d'effacement

Avis que, au moment de la compilation, le compilateur en a plein le type d'informations disponibles, mais cette information est volontairement abandonné en général lorsque le byte-code est généré, dans un processus connu sous le nom type d'effacement. C'est fait de cette façon en raison de problèmes de compatibilité: L'intention de la langue concepteurs a été de fournir le code source complet de la compatibilité et de plein octet code de la compatibilité entre les versions de la plate-forme. S'il était mis en œuvre différemment, vous devez recompiler vos applications héritées lors de la migration vers les nouvelles versions de la plate-forme. La façon dont c'était fait, toutes les signatures de méthode sont conservés (la compatibilité du code source) et que vous n'avez pas besoin de recompiler quoi que ce soit (compatibilité binaire).

Concernant réifiée génériques en Java

Si vous avez besoin de garder le type de compilation de l'information, vous avez besoin d'employer anonyme classes.
Le point est: dans le cas très particulier de anonyme des classes, il est possible de récupérer le plein au moment de la compilation des informations de type à l'exécution qui, en d'autres termes signifie: réifiée génériques. Cela signifie que le compilateur ne pas jeter les informations de type lorsque les classes anonymes sont impliqués; cette information est conservée dans le code binaire généré et le système d'exécution vous permet de récupérer cette information.

J'ai écrit un article sur ce sujet:

http://rgomes-info.blogspot.co.uk/2013/12/using-typetokens-to-retrieve-generic.html

Une remarque à propos de la technique décrite dans l'article ci-dessus est que la technique est obscur pour la majorité des développeurs. Malgré cela fonctionne et fonctionne bien, la plupart des développeurs se sentir confus ou mal à l'aise avec la technique. Si vous avez un code partagé de base ou d'un plan pour libérer votre code pour le public, je ne recommande pas la technique ci-dessus. D'autre part, si vous êtes l'unique utilisateur de votre code, vous pouvez profiter de la puissance de cette technique offre à vous.

Exemple de code

L'article ci-dessus a des liens vers des exemples de code.

OriginalL'auteur Richard Gomes

Les médicaments génériques en Langage Java est un très bon guide sur ce sujet.

Les génériques sont mis en œuvre en Java
compilateur comme une avant la fin de la conversion
appelé à l'effacement. Vous pouvez (presque) pense que
comme une source-à-source
traduction, par lequel le générique
la version de loophole() est converti à
le non-générique version.

Donc, c'est au moment de la compilation. La JVM ne saura jamais qui ArrayList vous avez utilisé.

Je recommande aussi M. Skeet sa réponse sur Quel est le concept de l'effacement dans les génériques en Java?

OriginalL'auteur Eugene Yokota

Le terme de type "effacement" n'est pas vraiment à la description correcte de Java problème avec les génériques.
Type d'effacement n'est pas en soi une mauvaise chose, en effet il est très nécessaire pour la performance et est souvent utilisé dans plusieurs langages tels que C++, Haskell, D.

Avant de dégoût, veuillez vous rappeler de la définition de type d'effacement de Wiki

Quel est le type d'effacement?

type d'effacement se réfère au temps de charge du processus par lequel les annotations de type explicites sont supprimés à partir d'un programme, avant qu'il soit exécuté au moment de l'exécution

Type d'effacement moyen de jeter les balises de type créé au moment de la conception ou déduit balises de type au moment de la compilation, tels que le programme compilé en code binaire ne contient pas de n'importe quel type de balises.
Et c'est le cas pour chaque langage de programmation de la compilation en code binaire, sauf dans certains cas où vous avez besoin d'exécution des balises. Ces exceptions comprennent par exemple tous les existentielle types (Java les Types de Référence qui sont subtypeable, n'Importe quel Type dans de nombreuses langues, Types d'Union).
La raison pour le type d'effacement est que les programmes se transforment en une langue qui est en quelque sorte uni-typés (langage binaire permettant seulement de bits) que les types sont des abstractions seulement et d'affirmer une structure pour ses valeurs et la sémantique pour les gérer.

C'est donc en retour, une normale chose de naturel.

De Java problème est différent et a causé à la façon dont elle réifie.

Souvent fait des déclarations à propos de Java n'a pas réifiée des génériques est également faux.

Java ne réification, mais dans un mauvais chemin des raisons de compatibilité descendante.

Ce qui est de la réification?

De notre Wiki

Réification est le processus par lequel une idée abstraite sur un programme d'ordinateur est transformé en un explicite du modèle de données ou d'un autre objet créé dans un langage de programmation.

Réification moyen de convertir quelque chose d'abstrait (Paramétrique de Type) en quelque chose de béton (Type) par spécialisation.

Nous illustrons cela par un exemple simple:

Une liste de tableaux avec définition:

ArrayList<T>
{
    T[] elems;
    ...//methods
}

est une abstraction, dans le détail d'un constructeur de type, qui est "réifiée" quand spécialisée avec un type concret, disons Entier:

ArrayList<Integer>
{
    Integer[] elems;
}

où ArrayList<Integer> est vraiment un type.

Mais c'est exactement la chose que Java ne marche pas!!!, au lieu de cela ils réification constamment résumé des types avec leurs limites, c'est à dire produisant le même type de béton indépendant des paramètres passés dans la spécialisation:

ArrayList
{
    Object[] elems;
}

qui est ici réifiée avec l'implicite de l'Objet lié (ArrayList<T extends Object> == ArrayList<T>).

Malgré qu'il rend le générique tableaux inutilisable et la cause de quelques erreurs étranges pour les matières premières, les types:

List<String> l= List.<String>of("h","s");
List lRaw=l
l.add(new Object())
String s=l.get(2) //Cast Exception

il provoque beaucoup d'ambiguïtés

void function(ArrayList<Integer> list){}
void function(ArrayList<Float> list){}
void function(ArrayList<String> list){}

reportez-vous à la même fonction:

void function(ArrayList list)

et, par conséquent, générique surcharge de la méthode ne peut pas être utilisé en Java.

OriginalL'auteur iconfly