Der einfachste Weg, Java Generics zu verstehen, besteht darin, es als eine bequeme Syntax zu betrachten, mit der Sie einige Vorgänge beim Casting von Java -Typen sparen können:
LISTE <APLEL> BOX = ...; Apple Apple = box.get (0);
Der obige Code selbst hat sich klar ausgedrückt: Box ist eine Liste mit Apple -Objekten. Die GET -Methode gibt eine Apple -Objektinstanz zurück, und dieser Prozess erfordert keine Typumwandlung. Es gibt keine Generika, der obige Code muss so geschrieben werden:
Listenfeld = ...; Apple Apple = (Apple) Box.get (0);
Es ist offensichtlich, dass der Hauptvorteil von Generika darin besteht, dass der Compiler die Typinformationen der Parameter beibehalten, Typprüfungen durchführt und Typ -Konvertierungsvorgänge durchführen: Der Compiler stellt sicher, dass diese Typkonvertierungen absolut korrekt sind. Im Vergleich dazu, sich auf Programmierer zu verlassen, um sich an Objekttypen zu erinnern und Typenkonvertierungen durchzuführen, verursacht dies Fehler, wenn das Programm ausgeführt wird, was schwer zu debuggen und zu lösen ist. Der Compiler kann Programmierern helfen, eine große Anzahl von Typprüfungen zum Kompilierungszeit zu erzwingen und Fehler zu finden.
Die Komposition von Generika
Die Zusammensetzung von Generika führt zum Konzept der Typvariablen. Gemäß der Java -Sprachspezifikation sind Typvariablen eine Art uneingeschränkter Glyphe, die sich aus den folgenden Situationen ergibt:
Generische Klassenerklärung generische Schnittstellenerklärung generische Methode Deklaration Generische Konstruktorerklärung
Generische Klassen und Schnittstellen
Wenn sich eine oder mehrere Typvariablen auf einer Klasse oder Schnittstelle befinden, ist es ein generisches. Typvariablen werden durch Winkelklammern definiert und nach dem Namen der Klasse oder des Schnittstellens platziert:
Öffentliche Schnittstellenliste <T> Erweitert die Sammlung <T> {...}Einfach ausgedrückt, die Rolle von Typvariablen ist wie ein Parameter, der dem Compiler Informationen für die Typprüfung zur Verfügung stellt.
Viele Klassen in der Java -Klassenbibliothek, wie z. B. das gesamte Sammelframework, wurden in generischer Form geändert. Die Listenschnittstelle, die wir im ersten Code oben verwendet haben, ist beispielsweise eine generische Klasse. In diesem Code handelt es sich bei Box um ein List <Apfel> -Objekt, das eine Instanz einer Klassenimplementierung einer Listenschnittstelle mit einer Variablen von Apple -Typen darstellt. Der Compiler verwendet diesen Typ -Variablenparameter, um die GET -Methode automatisch zu konvertieren, wenn sie aufgerufen wird, und gibt ein Apple -Objekt zurück.
Tatsächlich lautet dieses neu auftretende generische Tag oder die GET -Methode in dieser Listenschnittstelle wie folgt:
T GET (INT INDEX);
Die GET -Methode gibt tatsächlich ein Objekt vom Typ t zurück, bei dem es sich um eine Typvariable in der Liste <T> handelt.
Generische Methoden und Konstruktoren
Sehr ähnlich, wenn ein oder mehrere Typvariablen auf der Methode und dem Konstruktor deklariert werden, können sie auch generisch sein.
public static <t> t getFirst (Liste <T> Liste)
Diese Methode akzeptiert einen List <T> Parameter und gibt ein Objekt vom Typ T zurück. Typ-Safe-Schreibdaten ... Der folgende Code ist ein Beispiel. Wir erstellen eine Liste <string> Instanz und laden dann einige Daten:
Liste <String> str = new ArrayList <string> (); Str.add ("Hallo"); Str.add ("Welt");Wenn wir versuchen, ein anderes Objekt in List <String> zu laden, fordert der Compiler einen Fehler auf:
Str.add (1);
Typ-Safe-Lesedaten ...
Wenn wir ein List <String> -Objekt verwenden, garantiert es immer, dass wir ein String -Objekt erhalten:
String mystring = str.get (0);
TRAVERSAL: Viele Klassen in der Klassenbibliothek, wie z. B. Iterator <t>, haben verbesserte Funktionen und werden generiert. Die Iterator () -Methode in der Liste <T> gibt nun Iterator <t> zurück. Das von der m-Methode von T Next () zurückgegebene Objekt muss nicht vom Typ konvertiert werden. Sie erhalten direkt den richtigen Typ.
für (iterator <string> iter = str.iterator (); iter.hasnext ();) {String s = iter.next (); System.out.print (s);}Mit foreach profitiert auch die "für jede" Syntax von Generika. Der vorherige Code kann so geschrieben werden:
für (String S: str) {System.out.print (s);}Dies ist leicht zu lesen und zu warten.
Automatische Einkapselung (Autoboxing) und automatisches Auspacken (Autounboxing). Bei der Verwendung von Java -Generika werden die beiden Funktionen von Autoboxing/Autounboxing automatisch verwendet, genau wie der folgende Code:
LIST <NEGEGER> INTTS = New ArrayList <GanzEger> (); ints.Add (0); ints.Add (1); int sum = 0; für (int i: ints) {sum += i; }Eine Sache, die Sie jedoch verstehen müssen, ist, dass Verpackungen und Auspacken Leistungsverluste bringen, und der gesamte allgemeine Zweck sollte mit Vorsicht verwendet werden.
Generika sind ein neues Merkmal von Java SE 1.5. Die Essenz von Generika ist ein parametrisierter Typ, dh der Datentyp wird als Parameter angegeben. Dieser Parametertyp kann bei der Erstellung von Klassen, Schnittstellen und Methoden verwendet werden und wird generische Klassen, generische Schnittstellen bzw. generische Methoden genannt.
Der Vorteil der Einführung von Generika in Java -Sprache ist, dass sie sicher und einfach sind.
Vor der Java SE 1.5 ohne Generika wurde die "willkürliche" Parameter durch Bezugnahme auf das Typobjekt erreicht. Der Nachteil der "willkürlichen" darin bestand, dass explizite Konvertierung des Gusstyps erforderlich war und diese Konvertierung die Entwickler mussten, den tatsächlichen Parametertyp vorherzusagen. Im Falle von Konvertierungsfehlern für Gusstypen kann der Compiler keinen Fehler auffordern, und eine Ausnahme tritt nur beim Ausführen auf, was ein Sicherheitsrisiko darstellt.
Der Vorteil von Generika besteht darin, dass sie die Sicherheit des Typs beim Kompilieren überprüfen und alle Abgüsse automatisch und implizit sind, wodurch die Wiederverwendungsrate von Code verbessert wird.
Es gibt einige Regeln und Einschränkungen bei der Verwendung von Generika:
1. Die Typparameter generischer Typen können nur Klassentypen (einschließlich benutzerdefinierter Klassen) sein, nicht einfache Typen.
2. Der gleiche generische Typ kann mehreren Versionen entsprechen (weil der Parametertyp ungewiss ist), und die Instanzen der generischen Klasse verschiedener Versionen sind inkompatibel.
3.. Es kann mehrere Typparameter für Generika geben.
4. Generische Parametertypen können beispielsweise Erweiterungsanweisungen verwenden. Gewohnheitsmäßig ein "begrenzter Typ" werden.
5. Der Parametertyp eines generischen Typs kann auch ein Platzhaltertyp sein. Zum Beispiel Class classtype = class.forname (java.lang.String);
Generika haben auch Schnittstellen, Methoden usw. mit vielen Inhalten, und es erfordert einige Anstrengungen, um sie kompetent zu verstehen, zu beherrschen und anzuwenden. Hier sind zwei Beispiele, die ich geschrieben habe, als ich über Generika (geschrieben auf dem Eindruck, den ich gesehen habe) erfuhr, was dieselbe Funktion erkennen kann. Einer verwendet Generika und der andere nicht. Im Vergleich können Sie schnell die Anwendung von Generika lernen. Lernen Sie dies und lernen Sie im Grunde 70% des Inhalts von Generika.
Beispiel 1: Generika werden verwendet
öffentliche Klasse Gent {private t ob; // Definieren Sie die Variable der generischen Mitgliedsvariable öffentlich Gen (t ob) {this.ob = ob; } public t getOb () {return ob; } public void setOb (t ob) {this.ob = ob; } public void jodetyep () {System.out.println ("Die tatsächliche Art von t ist:" + ob.getClass (). getName ()); }} public class gendemo {public static void main (String [] args) {// Definieren Sie eine Ganzzahlversion der generischen Klasse Gen Gen IntOB = new Geninteger (88); intob.showtyep (); int i = intob.getOB (); System.out.println ("value =" + i); System.out.println("--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------Beispiel 2: Es werden keine Generika verwendet
öffentliche Klasse Gen2 {privates Objekt OB; // Definieren Sie ein allgemeines Typ Mitglied Public Gen2 (Objekt OB) {this.ob = ob; } public Object getOb () {return ob; } public void setOb (Objekt ob) {this.ob = ob; } public void jodetyep () {System.out.println ("Die tatsächliche Art von t ist:" + ob.getClass (). getName ()); }} public class gendemo2 {public static void main (String [] args) {// eine Integer -Version der Klasse Gen2 Gen2 intoB = new Gen2 (New Ganzzahl (88)); intob.showtyep (); int i = (Integer) intob.getOB (). i);System.out.println("------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------ strob.getOB (); System.out.println ("value =" + s);Auslaufergebnisse:
Die Ergebnisse des Ausführens der Demo in den beiden Beispielen sind gleich, und die Konsolenausgabe ist wie folgt:
Die tatsächliche Art von T ist:
Java.lang.Integer
Wert = 88
---------------------------------------
Die tatsächliche Art von T ist: Java.lang.String
Wert = Hallo Gen!
Vorgang mit dem Ausgangscode 0 abgeschlossen
Wenn Sie dies verstehen, werden Sie in Zukunft kein Problem sein, wenn grundlegende generische Anwendungen und Code lesen.
Das obige ist eine Beispielanalyse der Java -Generika. Freunde, die Java Generics lernen, können sich darauf beziehen.