L'effacement de type Java peut-il vraiment effacer complètement toutes les informations ?

Contexte : Nous savons tous que les génériques fournissent essentiellement des "paramètres de type" de types. Ils sont également appelés types paramétrés ou polymorphisme paramétrique. En fait, l'idée des génériques n'a pas été la première à être introduite en Java. Les modèles en C++ sont un exemple d'utilisation des génériques.

(Vidéo recommandée : tutoriel vidéo Java)

GJ (Java générique) est Une extension du langage Java, un langage Java avec des types paramétrés. Les programmes écrits en GJ ressemblent fondamentalement aux programmes Java ordinaires, sauf qu'ils ont plus de types paramétrés et moins de conversions de types. En fait, ces programmes GJ sont d'abord convertis en programmes Java ordinaires sans génériques puis traités par le compilateur qui termine automatiquement la traduction du Java générique vers le Java ordinaire.

Que sont les vrais génériques Java

Nous savons tous que le compilateur effectuera un effacement générique Le compilateur peut lors de la compilation de la source. programme (code Java avec génériques), utilisez les informations de type générique pour assurer la sécurité du type, vérifiez un grand nombre de contraintes de sécurité de type qui ne seraient pas vérifiées sans génériques, et en même temps, dans le bytecode généré, effacez ces informations de type. Vérifions-le d'abord :

public static void main(String[] args) {
 ArrayList<Integer> ints = new ArrayList<Integer>();
 ints.add(1); 
 ints.add(2);
 ints.add(3);
 ArrayList<String> sts = new ArrayList<String>();
 sts.add("a");
 sts.add("b");
 sts.add("c");
 System.out.println(ints.getClass() == sts.getClass()); 
}

Le résultat imprimé ci-dessus est vrai car

Selon la compréhension, la valeur d'origine ne peut pas être restaurée après un effacement générique. Les types sont le tout sous la forme d'un objet. Est-ce vraiment le cas ?

Regardez le code suivant :

import java.lang.reflect.ParameterizedType;import java.util.ArrayList;import java.util.List;public class ClassTest {     
public static void main(String[] args) throws Exception {
     ParameterizedType type = (ParameterizedType) 
     Bar.class.getGenericSuperclass();
     System.out.println(type.getActualTypeArguments()[0]);
     
     ParameterizedType fieldType = (ParameterizedType) 
     Foo.class.getField("children").getGenericType();
     System.out.println(fieldType.getActualTypeArguments()[0]);
     
     ParameterizedType paramType = (ParameterizedType) 
     Foo.class.getMethod("foo", List.class)
     .getGenericParameterTypes()[0];
     System.out.println(paramType.getActualTypeArguments()[0]);
     
     System.out.println(Foo.class.getTypeParameters()[0]
     .getBounds()[0]);
     }     
     class Foo<E extends CharSequence> {     
     public List<Bar> children = new ArrayList<Bar>();     
     public List<StringBuilder> foo(List<String> foo) {return null; }     
     public void bar(List<? extends String> param) {}
     }     
     class Bar extends Foo<String> {}
    }

Imprimez

class java.lang.Stringclass com.javapuzzle.davidwang456.ClassTest$Barclass java.lang.Stringinterface java.lang.CharSequence

Vous constaterez que chaque paramètre de type est conservé et peut être obtenu via un mécanisme de réflexion au moment de l'exécution. Alors, qu’est-ce que « l’effacement de type » exactement ? Au moins quelque chose a été effacé, non ? Oui. En fait, tout sauf les informations structurées est effacé - ici, les informations structurées font référence aux informations liées à la structure de la classe plutôt qu'au flux d'exécution du programme. En d’autres termes, les métadonnées liées à la classe, à ses champs et aux paramètres de type de ses méthodes sont préservées et peuvent être obtenues par réflexion.

Cet article provient du site Web php chinois, colonne tutoriel Java, bienvenue pour apprendre !

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!