[Java] Einfache Verwendung von Generika

---

1. Verpackung

Bevor wir Generika verstehen, verstehen wir zunächst, was eine Wrapper-Klasse ist. Da in Java der Basistyp nicht von Object erbt, entspricht Java zur Unterstützung von Basistypen im generischen Code jedem Basistyp einem Wrapper-Typ.

1. Grundlegende Datentypen und entsprechende Verpackungsklassen

Grundlegende Datentypen	Verpackung
Byte	Byte
kurz	Kurz
int	Ganze Zahl
lang	Lang
schweben	Schweben
doppelt	Doppelt
verkohlen	Charakter
Boolescher Wert	Boolescher Wert

AußerInteger und Character, die anderen Grundtypen Paketklassen werden alle groß geschrieben

2. Automatisches Einpacken und automatisches Auspacken

public class Test {
    
    
    public static void main(String[] args) {
    
    
        int a = 10;
        Integer i = a;//自动装箱 把一个基本数据类型转变为包装类型
        System.out.println(i);

        Integer j = new Integer(20);
        int b = j;//自动拆箱 把一个包装类型转变为基本数据类型
        System.out.println(b);
    }
}

3. Manuelles Verpacken und manuelles Auspacken

public class Test {
    
    
    public static void main(String[] args) {
    
    
        int a = 10;
        Integer i = Integer.valueOf(a);//手动装箱
        System.out.println(i);

        Integer j = new Integer(20);
        int b = j.intValue();//手动拆箱
        System.out.println(b);
    }
}

2. Was sind Generika?

Generika sind eine neue Syntax, die in JDK1.5 eingeführt wurde. Für den Laien ausgedrückt: Generika: ist auf viele Typen anwendbar. Aus Code-Sicht wird der Typ parametrisiert. Der Hauptzweck von Generika: Es besteht darin, den aktuellen Container anzugeben, welche Art von Objekt er enthalten möchte, und den Compiler die Überprüfung durchführen zu lassen< /span> a>
Syntax:

class 泛型类名称<类型形参列表> {
    
    
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> {
    
    
}
class 泛型类名称<类型形参列表> extends 继承类/* 这里可以使用类型参数 */ {
    
    
// 这里可以使用类型参数
}
class ClassName<T1, T2, ..., Tn> extends ParentClass<T1> {
    
    
// 可以只使用部分类型参数
}

Ein Beispiel ist unten dargestellt:

class MyArray<T> {
    
    
    public Object[] array = new Object[10];//1

    public void setValue(int pos,T val) {
    
    
        array[pos] = val;
    }
    public T getValue(int pos) {
    
    
        return(T)array[pos];
    }
}
public class Test {
    
    
    public static void main(String[] args) {
    
    
        MyArray<Integer> myArray = new MyArray<>();//2
        myArray.setValue(0,10);
        myArray.setValue(1,20);
        myArray.setValue(2,30);
        int val = myArray.getValue(0);//3
        System.out.println(val);
        
        MyArray<String> myArray1 = new MyArray<>();
        myArray1.setValue(0,"hello");
        myArray1.setValue(1,"word");
        String ret = myArray1.getValue(0);
        System.out.println(ret);
    }
}    

1. Das < T > nach dem Klassennamen stellt einen Platzhalter dar, der angibt, dass die aktuelle Klasse eine generische Klasse ist.
[Spezifikation] Typparameter werden im Allgemeinen durch a dargestellt Großbuchstabe. Häufig verwendete Namen sind:
E steht für Element
K steht für Schlüssel
V steht für Wert< a i=5 > N steht für Zahl T steht für Typ S, U, V usw. – der zweite, dritte, vierte Typ2. Hinweis 1: Arrays generischer Typen können nicht neu sein3. Hinweis 2: Fügen Sie < Integer > nach dem Typ hinzu, um den aktuellen Typ anzugeben 4. Hinweis 3: Es ist keine erzwungene Typkonvertierung erforderlich

3. Verwendung von Generika

Grammatik:

泛型类<类型实参> 变量名; // 定义一个泛型类引用
new 泛型类<类型实参>(构造方法实参); // 实例化一个泛型类对象

Beispiele sind wie folgt:

MyArray<Integer> myArray = new MyArray<Integer>();//此处的类型实参可以省略

Hinweis: Generics können nur Klassen akzeptieren und alle grundlegenden Datentypen müssen Wrapper-Klassen verwenden

4. Rohtyp

Ein nackter Typ ist eine generische Klasse ohne Typparameter, wie unten gezeigt:

MyArray myArray = new MyArray();

Hinweis: Wir sollten selbst keine nackten Typen verwenden. Nackte Typen sind ein Mechanismus, der der Kompatibilität mit älteren API-Versionen vorbehalten ist

5. Wie werden Generika zusammengestellt?

Löschmechanismus:
Während des Kompilierungsprozesses wird der Mechanismus zum Ersetzen aller T durch Object aufgerufen: Löschmechanismus
Der generische Mechanismus von Java ist unter implementiert die Kompilierungsebene. Der vom Compiler generierte Bytecode enthält zur Laufzeit keine generischen Typinformationen

6. Obergrenze der Generika

Beim Definieren einer generischen Klasse ist es manchmal notwendig, den übergebenen Typvariablen bestimmte Einschränkungen aufzuerlegen. Dies kann über Typgrenzen erfolgen
Syntax:

class 泛型类名称<类型形参 extends 类型边界> {
    
    
...
}

Beispiel:

public class MyArray<E extends Number> {
    
    
...
}

Akzeptiert nur Untertypen von Number als Typargumente von E
Komplexes Beispiel:

public class MyArray<E extends Comparable<E>> {
    
    
...
}

E muss die Comparable-Schnittstelle implementieren

7. Generische Methoden

Definitionssyntax:

方法限定符 <类型形参列表> 返回值类型 方法名称(形参列表) {
    
     
... 
}

Beispiel:

public class Util {
    
    
        //静态的泛型方法 需要在static后用<>声明泛型类型参数
        public static <E> void swap(E[] array, int i, int j) {
    
    
            E t = array[i];
            array[i] = array[j];
            array[j] = t;
        }
}

---

Zusammenfassen

1. Generics parametrisieren den Datentyp und übertragen ihn
2. Verwenden Sie < T >, um anzugeben, dass die aktuelle Klasse eine generische Klasse ist.
3. Die bisherigen Vorteile von Generika: Datentypparametrisierung, automatische Typprüfung und Konvertierung zur Kompilierungszeit