Beispielanalyse von Java-Generika und Wrapper-Klassen

1. Was sind Generika? Die Essenz von Generika besteht darin, Typen zu parametrisieren (die spezifischen Typen formaler Parameter durch verschiedene Typen zu steuern, die von Generika angegeben werden, ohne neue Typen zu erstellen).

Schauen wir uns zunächst das folgende Beispiel an:

Das Array, das wir zuvor gelernt haben, kann nur Elemente bestimmter Typen speichern. Zum Beispiel:

Die Object-Klasse ist die übergeordnete Klasse aller Klassen. Können wir also ein Obj-Array erstellen?

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);
    }
}

int[] array=new int[10];String[] array=new String[10];Nachdem der obige Code implementiert wurde, haben wir Folgendes gefunden:

Jeder Datentyp kann gespeichert werden
Die Datei Nummer 2 ist ursprünglich eine Zeichenfolge, aber sie muss zur Typkonvertierung gezwungen werden
in Generika einführen: Der Zweck von Generika besteht darin, anzugeben, welche Art von Objekt der aktuelle Container enthalten soll, und ihn vom Compiler selbst überprüfen zu lassen.

2. Generische Syntax:

Generischer Klassenname < Typparameterliste > Variablenname=neues generisches Klassenargument (Konstruktormethodenargument) Platzhalter, der angibt, dass die aktuelle Klasse eine generische Klasse ist

Beim Instanziieren einer generischen Klasse kann <> kein einfacher Typ sein, es muss eine Wrapper-Klasse sein

<> Nimmt nicht an der teil Typzusammensetzung von Generika

Es können keine neuen Arrays von generischen Typen erstellt werden

Die Verwendung von Generika erfordert keine erzwungene Typkonvertierung

Ein einfaches Generikum:

//此处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;
    }
}

• Löschmechanismus: Die Typen in <> werden gelöscht während der Kompilierung, sodass die Dinge in <> nicht an der Zusammensetzung des Typs beteiligt sind. Löscht T als Objekt.
  Warum kann ich ein Array generischen Typs nicht instanziieren?
• Ein wichtiger Unterschied zwischen Arrays und Generika besteht darin, wie sie die Typprüfung erzwingen. Arrays speichern und prüfen Typinformationen zur Laufzeit, während Generics zur Kompilierungszeit auf Typfehler prüfen.
  Das zurückgegebene Objektarray kann jede Art von Daten speichern, z. B. eine Zeichenfolge, die über ein Array vom Typ int empfangen wird. Der Compiler betrachtet es als unsicher. ?? oder eine Unterklasse von Number

• public class MyArray>{}
• //E muss eine Klasse sein, die die Comparable-Schnittstelle implementiert

[Hinweis] E ohne angegebene Grenzen, Kann sein Gilt als E erweitert Object

• 4, Wildcard

? Für die Verwendung in Generika ist es ein Platzhalter. Platzhalter werden verwendet, um das Problem zu lösen, dass antigenerische Typen nicht kovariant sein können.

Die folgenden zwei Codeteile:

代码一：
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);
   }
}

Wildcards werden in Code 2 verwendet. Im Vergleich zu Code 1 kennen wir derzeit nicht den spezifischen Datentyp, der an Code 1 übergeben wird. ?? Tierunterklassen.

Animal

Cat erweitert Animal

Dog erweitert Animal

Code 1:

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

Zu diesem Zeitpunkt ist der T-Typ eine Unterklasse von Animal oder sich selbst.

Code 2: Implementiert durch Platzhalter

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

Der Unterschied zwischen den beiden Codes:

Für die von Generics implementierte Methode schränkt T ein und kann nur eine Unterklasse von Animal sein. Geben Sie Cat ein, es ist Cat.

Für Methoden, die durch Platzhalter implementiert werden, ist dies gleichbedeutend damit, Animal festzulegen und die Übergabe von Unterklassen von Animal zuzulassen. Die konkrete Unterkategorie ist derzeit nicht klar. Beispiel: Wenn Cat übergeben wird, ist der deklarierte Typ Animal. Nur durch Verwendung von Polymorphismus kann die toString-Methode von Cat aufgerufen werden.

Obere Grenze der Wildcards→ um Platzhalter zu verwenden, um den Eltern-Kind-Typ zu bestimmen.

MyArrayList Was in der Liste gespeichert ist, kann eine Zahl oder eine Unterklasse von Zahl sein, und der Typ kann nicht bestimmt werden.

Die Platzhalterobergrenze eignet sich zum Lesen, nicht zum Schreiben.

(2) Untere Grenze des Platzhalters

Syntax:

//Der Parametertyp, der übergeben werden kann, ist Integer oder die übergeordnete Klasse von Ganzzahl

Eltern-Kind-Klassenbeziehung der Wildcard-Untergrenze:

MyArrayList是MyArrayList的父类类型

MyArrayList<？>是MyArrayList的父类

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

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;//隐式的拆箱

Das obige ist der detaillierte Inhalt vonBeispielanalyse von Java-Generika und Wrapper-Klassen. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!