Un examen plus approfondi des génériques en Java

Définition des génériques : Les génériques sont une nouvelle fonctionnalité du JDK 1.5, et son essence est l'application de types paramétrés (Parameterized Type), c'est-à-dire en d'autres termes, le type de données utilisé est spécifié en tant que paramètre et le type spécifique est spécifié lorsqu'il est utilisé. Ce type de paramètre peut être utilisé dans la création de classes, d'interfaces et de méthodes, appelées respectivement classes génériques, interfaces génériques et méthodes génériques.

L'idée des génériques a commencé à prendre racine dès les modèles du langage C++ Lorsque le langage Java était dans une version où les génériques n'étaient pas encore apparus, Object ne pouvait être utilisé. en tant que classe parent de tous les types, la généralisation des types peut être obtenue en combinant les deux caractéristiques de la coercition des types. Par exemple, lors de l'accès aux tables de hachage, avant JDK 1.5, la méthode get() de HashMap était utilisée et la valeur de retour était un objet Object Puisque tous les types du langage Java héritent de java.lang.Object, l'Object. peut être transformé en n’importe quel objet. C’est possible à Chengdu. Mais comme les possibilités sont infinies, seuls le programmeur et la machine virtuelle au moment de l'exécution savent de quel type d'objet il s'agit. Lors de la compilation, le compilateur ne peut pas vérifier si la transformation forcée de cet objet a réussi. Si l'on compte uniquement sur le programmeur pour garantir l'exactitude de cette opération, de nombreux risques de ClassCastException seront transférés au runtime du programme.

L'utilisation de la technologie générique en C# et Java semble être la même, mais il existe des différences fondamentales dans l'implémentation. En C#, les génériques sont utilisés à la fois dans le code source du programme et dans l'IL (Langage Intermédiaire) compilé. . , langage intermédiaire, les génériques sont actuellement un espace réservé) ou dans le CLR au moment de l'exécution. List et List sont deux types différents, qui sont générés lors de l'exécution du système. données, cette implémentation est appelée inflation de type, et les génériques implémentés sur la base de cette méthode sont appelés génériques réels.

Les génériques en langage Java sont différents. Ils n'existent que dans le code source du programme, ils ont été remplacés par le type brut d'origine (Raw Type, également appelé type Naked), et le type brut. le code de conversion est inséré à l'endroit correspondant, donc pour le langage d'exécution Java, ArrayList et ArrayList Par conséquent, la technologie générique est en fait un sucre syntaxique du langage Java. La méthode d'implémentation générique dans le langage Java est appelée effacement de type, et les génériques implémentés sur la base de cette méthode sont appelés pseudo-génériques. (L'effacement de type sera étudié plus tard)

Le code de programme écrit à l'aide du mécanisme générique est plus sécurisé et plus sûr que le code qui utilise de manière désordonnée des variables d'objet et effectue ensuite une conversion de type forcée. Les génériques sont particulièrement utiles pour les classes de collection.

1. Pourquoi utiliser des génériques

Nous examinons ici un morceau de code ;

List list = new ArrayList();  
list.add("CSDN_SEU_Cavin");  
list.add(100);  
for (int i = 0; i < list.size(); i++) {  
  String name = (String) list.get(i); //取出Integer时，运行时出现异常  
System.out.println("name:" + name);  
}

Cet exemple A Une valeur de type chaîne et une valeur de type Integer sont ajoutées à la collection de types de liste. (C'est légal car le type de liste par défaut est Objet). Dans la boucle suivante, en raison de l'oubli d'ajouter une valeur de type Integer à la liste avant ou pour d'autres raisons, une exception java.lang.ClassCastException se produira au moment de l'exécution. Pour résoudre ce problème, les génériques ont vu le jour.

2. Utilisation de génériques

Les génériques permettent aux programmeurs d'utiliser l'abstraction de types, généralement utilisée dans les collections.

List<String> list = new ArrayList<String>();

Écrite ainsi, la méthode d'acquisition de valeur de boucle ci-dessus ne signalera pas d'erreur et il n'est pas nécessaire d'effectuer une conversion de type. Grâce à List, il est directement limité que la collection de listes ne puisse contenir que des éléments de type String.

3. Les génériques ne sont valables que lors de la compilation

Nous devons également comprendre lors de l'utilisation de génériques Que se passe-t-il lorsque des génériques sont compilés, donc ici, nous devons prêter une attention particulière à : les génériques ne sont valides que lorsque le code est compilé dans un fichier de classe

AyyayList<String> a = new ArrayList<String>();  
ArrayList b = new ArrayList();  
Class c1 = a.getClass();  
Class c2 = b.getClass();  
System.out.println(a == b);

Sortie du programme ci-dessus Le résultat est vrai. En effet, toutes les opérations de réflexion sont effectuées au moment de l'exécution. Puisque c'est vrai, cela prouve qu'après la compilation, le programme prendra des mesures de dégénérisation.

Autrement dit, les génériques en Java ne sont valables que pendant la phase de compilation. Pendant le processus de compilation, une fois les résultats génériques correctement vérifiés, les informations pertinentes des génériques seront effacées et des méthodes de vérification de type et de conversion de type seront ajoutées aux limites des méthodes d'entrée et de sortie de l'objet. En d’autres termes, Le fichier de classe compilé avec succès ne contient aucune information générique. Les informations génériques n'entrent pas dans la phase d'exécution .

Le code suivant explique très bien que les génériques ne sont valables que lors de la compilation via le mécanisme de réflexion de Java

ArrayList<String> a = new ArrayList<String>();  
a.add("CSDN_SEU_Cavin");  
Class c = a.getClass();  
try{  
    Method method = c.getMethod("add",Object.class);  
    method.invoke(a,100);  
    System.out.println(a);  //[CSDN_SEU_Cavin, }catch(Exception e){  
    e.printStackTrace();

　Classes génériques et génériques. méthodes

public static class FX<T> {  
    private T ob; // 定义泛型成员变量  
  
    public FX(T ob) {  
        this.ob = ob;  
    }  
  
    public T getOb() {  
        return ob;  
    }  
  
    public void showTyep() {  
        System.out.println("T的实际类型是: " + ob.getClass().getName());  
    }  
}  
    public static void main(String[] args) {  
        FX<Integer> intOb = new FX<Integer>(100);  
        intOb.showTyep();  
        System.out.println("value= " + intOb.getOb());  //java.lang.Integer  System.out.println("----------------------------------");  
  
        FX<String> strOb = new FX<String>("CSDN_SEU_Calvin");  
        strOb.showTyep();  
        System.out.println("value= " + strOb.getOb());  //value= 100 } 
　　

　5. Avantages des génériques

(1) Type sécurité.

En connaissant les restrictions de type des variables définies à l'aide de génériques, le compilateur peut améliorer plus efficacement la sécurité des types des programmes Java.

　 (2) Éliminez la conversion de type forcée.

Élimine de nombreux casts dans le code source. Cela rend le code plus lisible et réduit les risques d'erreurs. Tous les castings sont automatiques et implicites.

　(3) Améliorer les performances

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!