Analyse de la prise en main des génériques Java

1. Que sont les génériques ?

Les génériques transmettent en fait des types en tant que paramètres. Les génériques permettent aux programmeurs d'utiliser certains types spécifiés ultérieurement lors de l'écriture du code, et d'utiliser le type souhaité comme paramètre lors de l'instanciation de la classe. genres.

Pourquoi introduire les génériques ?

Par exemple : implémentez vous-même une table de séquence

public class MyArrayList {
    public int[] elem;
    public int usedSize;

    public MyArrayList() {
        this.elem = new int[10];
    }
    // add方法
    public void add(int val) {
        // 暂时不考虑扩容问题，这里只是为了讲泛型
        elem[usedSize++] = val;
    }
    // get方法
    public int get(int pos) {
        return elem[pos];
    }
}

On peut voir ici que lors de l'utilisation de la table de séquence personnalisée ci-dessus, nous ne pouvons ajouter que des éléments de type int. Nous savons que la table de séquence de la collection Java peut ajouter n'importe quel type. Comment les données sont-elles obtenues ? Ici, nous essayons d'abord de changer le type int en type Object, afin de pouvoir garantir que n'importe quel type peut être transmis.

public class MyArrayList {
    public Object[] elem;
    public int usedSize;

    public MyArrayList() {
        this.elem = new Object[10];
    }
    // add方法
    public void add(Object val) {
        // 暂时不考虑扩容问题，这里只是为了讲泛型
        elem[usedSize++] = val;
    }
    // get方法
    public Object get(int pos) {
        return elem[pos];
    }
}

Lors de l'ajout de données à l'objet dans la méthode principale, vous pouvez ajouter n'importe quel type de données. Cependant, lorsque des données doivent être supprimées, car le type renvoyé est Object, une conversion forcée est nécessaire pour les recevoir avec le type correspondant, ce qui est très gênant.

public static void main(String[] args) {
        MyArrayList myArrayList = new MyArrayList();
        myArrayList.add(1);
        myArrayList.add("hello");
        int array1 = (int)myArrayList.get(0);
        String array2 = (String)myArrayList.get(1);
    }

La question est donc : dois-je forcer le transfert à chaque fois avant de pouvoir le recevoir ? Puis-je ne pas forcer le transfert ? A cette époque, nous pensions que lors de la création d'un objet instance, nous pouvions passer le type souhaité en paramètre, afin que toutes les données du type transmis puissent être stockées dans cet objet, puis lorsqu'il est retiré, toutes les données y sont. l'objet peut être clarifié. Ils sont tous de ce type, pas besoin de forcer le transfert. Cela introduit les génériques.

public class MyArrayList<E> {
	// 在编写程序时，不指定具体的类型，而用<E>这里的E来暂时代替
    // 具体的类型在实例化对象时传入
    public E[] elem;
    public int usedSize;

    public MyArrayList() {
    	// 这里的写法不是特别准确，应该用反射机制，这里先这样写
        this.elem = (E[])new Object[10];
    }
    // add方法
    public void add(E val) {
        // 暂时不考虑扩容问题，这里只是为了讲泛型
        elem[usedSize++] = val;
    }
    // get方法
    public E get(int pos) {
        return elem[pos];
    }
}

public static void main(String[] args) {

        MyArrayList<Integer> myArrayList1 = new MyArrayList<>();
        myArrayList1.add(1);
        myArrayList1.add(3);
        // myArrayList1.add("world");// 这里会报错，因为传入的数据不是指定的类型，所以泛型还有自动对类型进行检查的作用
        int I1 = myArrayList1.get(0);
        
        MyArrayList<String> myArrayList2 = new MyArrayList<>();
        myArrayList2.add("hello");
        myArrayList2.add("world");
        String s1 = myArrayList2.get(0);
    }

Cela garantit que tout type de données peut être transmis, et il n'est pas nécessaire de forcer le transfert lors de leur suppression ! La signification des génériques :

1. Vérifier automatiquement le type

2. Effectuer automatiquement une conversion de type forcée sur le type

Alors, quel est le type de l'objet correspondant de MyArrayList ici ? Est-ce MyArrayList

On voit ici que les types d'objets créés par les instances sont tous MyArrayList, et le contenu dans ? Cela nécessite de comprendre le mécanisme de fonctionnement des génériques.

2. Comment les génériques sont compilés

Une différence importante entre les tableaux et les génériques réside dans la manière dont ils appliquent la vérification de type. Plus précisément, les tableaux stockent et vérifient les informations de type au moment de l'exécution. Cependant, les génériques vérifient les erreurs de type au moment de la compilation et ne disposent d'aucune information de type au moment de l'exécution.

Mécanisme de compilation générique : mécanisme d'effacement

Lors de la compilation, E dans MyArrayList est effacé dans le type Object.

sont tous modifiés en type MyArrayList dans la méthode principale.

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!