Ein genauerer Blick auf Generika in Java

Definition von Generics: Generics sind eine neue Funktion von JDK 1.5, und ihr Kern besteht in der Anwendung parametrisierter Typen (parametrisierter Typ). Das heißt, der Datentyp, der bearbeitet wird, wird als Parameter angegeben und der spezifische Typ wird bei Verwendung angegeben. Dieser Parametertyp kann bei der Erstellung von Klassen, Schnittstellen und Methoden verwendet werden, die als generische Klassen, generische Schnittstellen bzw. generische Methoden bezeichnet werden.

Die Idee der Generika begann bereits in den Vorlagen der C++-Sprache Fuß zu fassen. Als die Java-Sprache in einer Version war, in der es noch keine Generika gab, konnte nur Object verwendet werden Als übergeordnete Klasse aller Typen kann eine Typverallgemeinerung durch die Kombination der beiden Merkmale des Typzwangs erreicht werden. Beim Zugriff auf Hash-Tabellen wurde beispielsweise die Methode get() von HashMap vor JDK 1.5 verwendet. Der Rückgabewert ist ein Object-Objekt, da alle Typen in der Java-Sprache von java.lang.Object erben in jedes beliebige Objekt verwandelt werden kann. Da es aber unendlich viele Möglichkeiten gibt, wissen nur der Programmierer und die virtuelle Maschine zur Laufzeit, um welche Art von Objekt es sich bei diesem Objekt handelt. Während der Kompilierung kann der Compiler nicht überprüfen, ob die erzwungene Transformation dieses Objekts erfolgreich ist. Wenn der Programmierer sich ausschließlich darauf verlässt, die Korrektheit dieser Operation sicherzustellen, werden viele Risiken von ClassCastException auf die Programmlaufzeit übertragen.

Die Verwendung generischer Technologie in C# und Java scheint gleich zu sein, es gibt jedoch grundlegende Unterschiede in der Implementierung. In C# werden Generika sowohl im Programmquellcode als auch in der kompilierten IL (Intermediate Language) verwendet. ., Zwischensprache, derzeit ein Platzhalter) oder in der CLR zur Laufzeit sind zwei verschiedene Typen, die während der Systemlaufzeit generiert werden Daten wird diese Implementierung als Typinflation bezeichnet, und die auf dieser Methode implementierten Generika werden als echte Generika bezeichnet.

Generics in der Java-Sprache sind anders. Sie sind nur im Programmquellcode vorhanden und wurden durch den ursprünglichen Rohtyp (Raw Type, auch als Naked Type bekannt) ersetzt Der Umwandlungscode wird an der entsprechenden Stelle eingefügt, daher sind ArrayList für die Laufzeit-Java-Sprache dieselbe Klasse. Daher ist die generische Technologie tatsächlich ein syntaktischer Zucker der Java-Sprache. Die generische Implementierungsmethode in der Java-Sprache wird als Typlöschung bezeichnet, und die auf dieser Methode implementierten Generika werden als Pseudo-Generika bezeichnet. (Typlöschung wird später untersucht)

Mit dem generischen Mechanismus geschriebener Programmcode ist sicherer und sicherer als Code, der Objektvariablen unordentlich verwendet und dann eine erzwungene Typumwandlung durchführt. Generika sind besonders nützlich für Sammlungsklassen.

1. Warum Generika verwenden

Hier sehen wir uns einen Code an;

List list = new ArrayList();  
list.add("CSDN_SEU_Cavin");  
list.add(100);  
for (int i = 0; i < list.size(); i++) {  
  String name = (String) list.get(i); //取出Integer时，运行时出现异常  
System.out.println("name:" + name);  
}

Dieses Beispiel A Der Listentypsammlung werden ein Wert vom Typ „String“ und ein Wert vom Typ „Integer“ hinzugefügt. (Dies ist zulässig, da der Standardtyp der Liste „Objekt“ ist). In der nachfolgenden Schleife tritt zur Laufzeit eine java.lang.ClassCastException-Ausnahme auf, weil vergessen wurde, der Liste zuvor einen Wert vom Typ „Integer“ hinzuzufügen, oder aus anderen Gründen. Um dieses Problem zu lösen, wurden Generika entwickelt.

2. Verwendung von Generika

Generika ermöglichen Programmierern die Verwendung der Typabstraktion, die normalerweise in Sammlungen verwendet wird.

List<String> list = new ArrayList<String>();

So geschrieben, meldet die obige Methode zur Schleifenwerterfassung keinen Fehler und es ist keine Typkonvertierung erforderlich. Durch List wird direkt eingeschränkt, dass die Listensammlung nur Elemente vom Typ String enthalten kann.

3. Generika sind nur während der Kompilierung gültig

Wir müssen auch verstehen, was bei der Verwendung von Generika passiert werden kompiliert, daher müssen wir hier besonders darauf achten: Generika sind nur gültig, wenn der Code in eine Klassendatei kompiliert wird

AyyayList<String> a = new ArrayList<String>();  
ArrayList b = new ArrayList();  
Class c1 = a.getClass();  
Class c2 = b.getClass();  
System.out.println(a == b);

Ausgabe des obigen Programms Das Ergebnis ist WAHR. Dies liegt daran, dass alle Reflexionsvorgänge zur Laufzeit ausgeführt werden. Dies beweist, dass das Programm nach der Kompilierung Degenerisierungsmaßnahmen ergreift.

Mit anderen Worten: Generika in Java sind nur während der Kompilierungsphase gültig. Während des Kompilierungsprozesses werden nach korrekter Überprüfung der generischen Ergebnisse die relevanten Informationen der generischen Elemente gelöscht und an den Grenzen der Eingangs- und Ausgangsmethoden des Objekts werden Methoden zur Typprüfung und Typkonvertierung hinzugefügt. Mit anderen Worten: Die erfolgreich kompilierte Klassendatei enthält keine allgemeinen Informationen. Allgemeine Informationen gelangen nicht in die Laufzeitphase .

Der folgende Code erklärt sehr gut, dass Generika nur während der Kompilierung durch den Reflexionsmechanismus von Java gültig sind

ArrayList<String> a = new ArrayList<String>();  
a.add("CSDN_SEU_Cavin");  
Class c = a.getClass();  
try{  
    Method method = c.getMethod("add",Object.class);  
    method.invoke(a,100);  
    System.out.println(a);  //[CSDN_SEU_Cavin, }catch(Exception e){  
    e.printStackTrace();

　4 Methoden

public static class FX<T> {  
    private T ob; // 定义泛型成员变量  
  
    public FX(T ob) {  
        this.ob = ob;  
    }  
  
    public T getOb() {  
        return ob;  
    }  
  
    public void showTyep() {  
        System.out.println("T的实际类型是: " + ob.getClass().getName());  
    }  
}  
    public static void main(String[] args) {  
        FX<Integer> intOb = new FX<Integer>(100);  
        intOb.showTyep();  
        System.out.println("value= " + intOb.getOb());  //java.lang.Integer  System.out.println("----------------------------------");  
  
        FX<String> strOb = new FX<String>("CSDN_SEU_Calvin");  
        strOb.showTyep();  
        System.out.println("value= " + strOb.getOb());  //value= 100 } 
　　

　5． Vorteile von Generika

　 (1) Typensicherheit.

Durch die Kenntnis der Typbeschränkungen von Variablen, die mithilfe von Generika definiert wurden, kann der Compiler die Typsicherheit von Java-Programmen effektiver verbessern.

　 (2) Beseitigen Sie die erzwungene Typkonvertierung.

Eliminieren Sie viele Umwandlungen im Quellcode. Dadurch wird der Code besser lesbar und die Fehlerwahrscheinlichkeit verringert. Alle Umwandlungen erfolgen automatisch und implizit.

　(3) Leistung verbessern

Das obige ist der detaillierte Inhalt vonEin genauerer Blick auf Generika in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!