Analyse des exemples de génériques Java et de classe wrapper

1. Que sont les génériques

L'essence des génériques est de paramétrer les types (contrôler les types spécifiques de paramètres formels à travers différents types spécifiés par les génériques sans créer de nouveaux types).

Regardons d'abord l'exemple suivant :

Le tableau que nous avons appris auparavant ne peut stocker que des éléments de types spécifiés. Par exemple : int[] array=new int[10];String[] array=new String[10];La classe Object est la classe parent de toutes les classes, pouvons-nous donc créer un tableau Obj ?

class Myarray{
    public Object[] array=new Object[10];
    public void setVal(int pos,Object val){
        this.array[pos]=val;
    }
    public Object getPos(int pos){
        return this.array[pos];
    }
}
public class TestDemo{
    public static void main(String[] args) {
        Myarray myarray=new Myarray();
        myarray.setVal(1,0);
        myarray.setVal(2,"shduie");//字符串也可以存放
        String ret=(String)myarray.getPos(2);//虽然我们知道它是字符串类型，但是还是要强制类型转换
        System.out.println(ret);
    }
}

Après l'implémentation du code ci-dessus, nous avons trouvé :

• Tout type de données peut être stocké

• Le fichier numéro 2 est à l'origine une chaîne, mais il faut le forcer à taper la conversion

pour introduisez les génériques, le but des génériques est de spécifier quel type d'objet le conteneur actuel doit contenir et de laisser le compilateur le vérifier par lui-même.

2. Syntaxe générique

class Nom de classe générique {

//Les paramètres de type peuvent être utilisés ici

}

Utilisation de génériques :

Classe générique nom de la variable = nouveau Classe générique (argument de la méthode du constructeur)

MyArray list=new MyArray();

【Remarque】

• Le espace réservé, indiquant que la classe actuelle est une classe générique

• Lors de l'instanciation d'un générique, ne peut pas être un type simple, il doit s'agir d'une classe wrapper

• Ne participe pas au composition de types de génériques

• Impossible de créer de nouveaux tableaux de types génériques

• L'utilisation de génériques ne nécessite pas de conversion de type forcée

Un générique simple :

//此处T可以随便写为任意标识，常见的如T、E、K、V等形式的参数常用于表示泛型
//在实例化泛型类时，必须指定T的具体类型
public class Test<T>{ 
    //key这个成员变量的类型为T,T的类型由外部指定  
   private T key;
 
    public Test(T key) { //泛型构造方法形参key的类型也为T，T的类型由外部指定
        this.key = key;
    }
 
    public T getKey(){ //泛型方法getKey的返回值类型为T，T的类型由外部指定
        return key;
    }
}

Mécanisme d'effacement : les types dans lors de la compilation, donc les éléments ne participeront pas à la composition du type. Effacera T comme objet.

Pourquoi ne puis-je pas instancier un tableau de type générique ?

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. Les tableaux stockent et vérifient les informations de type au moment de l'exécution, tandis que les génériques vérifient les erreurs de type au moment de la compilation.

Le tableau Object renvoyé peut stocker tout type de données, telles qu'une chaîne, qui est reçu via un tableau de type int. Le compilateur le considère comme dangereux.

3. Limite supérieure des génériques

Syntaxe :

nom de classe générique {

}

Exemple :

classe publique MyArray{} //E uniquement peut être un nombre ou une sous-classe de Number

classe publique MyArray>{}

//E doit être une classe qui implémente l'interface Comparable

[Note] E sans limites spécifiées, peut être considéré comme E étend l'objet

4, caractère générique

 ? Pour une utilisation dans les génériques, il s'agit d'un caractère générique. Les caractères génériques sont utilisés pour résoudre le problème selon lequel les types anti-génériques ne peuvent pas être covariants.

Les deux morceaux de code suivants :

代码一：
public static<T> void printList1(ArrayList<T> list){
   for(T x:list){
      System.out.println(x);
   }
}
 
代码二：
public static<T> void printList2(ArrayList<?> list){
   for(Object x:list){
      System.out.println(x);
   }
}

Les caractères génériques sont utilisés dans le code 2. Par rapport au code 1, nous ne connaissons pas le type de données spécifique transmis dans le code 1 pour le moment.

(1) Limite supérieure du caractère générique

Syntaxe :

extends upperbound>

Exemple : Pour la relation suivante, nous devons écrire une méthode pour imprimer la liste qui stocke Animal ou Sous-classes d'animaux.

Animal

Cat étend Animal

Dog étend Animal

Code 1 :

public static <t extends Animal> void print1(List<T> list>{
    for(T animal:list){
        System.out.println(animal);//调用了T的toString
    }
}

À l'heure actuelle, le type T est une sous-classe d'Animal ou de lui-même.

Code 2 : implémenté via des caractères génériques

public static void print2(List<? extends Animal> list){
    for(Animal animal:list){
       Syatem.out.println(animal);//调用了子类的toString方法
    }
}

La différence entre les deux codes :

Pour la méthode implémentée par les génériques, restreint T et ne peut être qu'une sous-classe d'Animal. Passez Cat, c'est Cat.
Pour les méthodes implémentées par des caractères génériques, cela équivaut à stipuler Animal et à autoriser la transmission des sous-classes d'Animal. La sous-catégorie spécifique n’est pas claire pour le moment. Par exemple : lorsque Cat est transmis, le type déclaré est Animal. Ce n'est qu'en utilisant le polymorphisme que la méthode toString de Cat peut être appelée
Limite supérieure des caractères génériques→ utiliser des caractères génériques pour déterminer le type parent-enfant

MyArrayList extends Number> est la classe parent de MyArrayList ou MyArrayList

MyArrayList> ce qui est stocké dans la liste peut être Number ou une sous-classe de Number, et le type ne peut pas être déterminé.

La limite supérieure du caractère générique convient à la lecture mais pas à l'écriture.

(2) Limite inférieure du caractère générique

Syntaxe :

• super lower limit>
• super Integer>//Le type de paramètre qui peut être transmis est Integer ou la classe parent de Entier

Relation de classe parent-enfant de la limite inférieure générique :

MyArrayList super Integer>是MyArrayList的父类类型

MyArrayList是MyArrayList super Integer>的父类

通配符下界适合写入元素，不适合读取。

5、包装类

在Java中，由于基本类型不是继承自Object，为了在泛型中可以支持基本类型，每个基本类型都对应了一个包装类。除了Integer和Character，其余基本类型的包装类都是首字母大写。

拆箱和装箱：

int i=10;
 
//装箱操作，新建一个Integer类型对象，将i的值放入对象的某个属性中
Integer ii=i;  //自动装箱
//Integer ii=Integer.valueOf(i);
Integer ij= new Integer(i);//显示装箱
 
//拆箱操作，将Integer对象中的值取出，放到一个基本数据类型中
int j=ii.intValue();//显示的拆箱
int jj=ii;//隐式的拆箱

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!