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 d0cfdd65c3b98b5db26a20872d6fceac {

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

}

Utilisation de génériques :

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

MyArray list=new MyArraya8093152e673feb7aba1828c43532094();

【Remarque】

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

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

• a8093152e673feb7aba1828c43532094Ne 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 a8093152e673feb7aba1828c43532094 lors de la compilation, donc les éléments a8093152e673feb7aba1828c43532094 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 f01bc2c3b14e38d550c5c56547c81726{

}

Exemple :

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

classe publique MyArray587c6b841f9775ac09a42ccb3bfcf6bc>{}

//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 :

b6b24cff7aea61f4b9dfa82bc05f59f5

de4ecefc77422169460f99db8e741841 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

MyArrayLista2b037db85f4e1df0e812b9647ac55a8 est la classe parent de MyArrayListc0f559cc8d56b43654fcbe4aa9df7b4a ou MyArrayListeafb63d086dd6c9bd19609d76bcc2869

MyArrayList6b3d0130bba23ae47fe2b8e8cddf0195 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 :

• b638d012cf4dd82c31c33e9b50bcb297
• 474555482eb79f9e4e676a9012437c1d//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 :

MyArrayList474555482eb79f9e4e676a9012437c1d是MyArrayList1c0477c859e3a4cbd4faa63087d62a35的父类类型

MyArrayLista10469e4b40f04339ce5bebfbf5abb4c是MyArrayList474555482eb79f9e4e676a9012437c1d的父类

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

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!