Generika in Java bieten Sicherheit für Kompilierzeit und eliminieren die Notwendigkeit des Gie?ens, indem Klassen, Schnittstellen und Methoden mit Typparametern arbeiten k?nnen. Beispielsweise stellt die Verwendung von List sicher, dass nur Zeichenfolgen hinzugefügt werden k?nnen, wodurch die Laufzeitklassenversuche verhindern k?nnen. Generika funktionieren über Typparameter wie , um wiederverwendbare Code wie eine Box -Klasse zu aktivieren, die einen beliebigen Typ enth?lt. Zu den wichtigsten Vorteilen geh?ren die Sicherheitstypsicherheit, kein Casting und die Wiederverwendbarkeit von Code; Gemeinsame generische Sammlungen umfassen Listen , eingestellt , MAP und Warteschlange ; Grenztypparameter wie die Typen auf Unterklassen einer bestimmten Klasse ein. Typ -L?schen beseitigt generische Typinformationen zur Laufzeit für die Rückw?rtskompatibilit?t. Wildcards >, erweitert t> und Super t> Erm?glichen Sie eine flexible Subtyping, z. B. die Annahme einer Liste von Zahlen in einem Methodeparameter.

Generika in Java ist eine Funktion, mit der Sie Klassen, Schnittstellen und Methoden schreiben k?nnen, die mit unterschiedlichen Datentypen funktionieren und gleichzeitig die Sicherheit des Kompilierungszeittyps bereitstellen k?nnen. Es erm?glicht Ihnen, eine Klasse oder Methode mit Platzhaltern (Typparametern) für die Datentypen zu definieren, die bei Verwendung der Klasse oder Methode angegeben werden.

Warum Generika nützlich sind

Bevor Generika in Java 5 eingeführt wurden, konnten Sammlungen wie ArrayList jegliche Art von Objekten enthalten. Diese Flexibilit?t lag mit Kosten: Sie mussten beim Abrufen von Objekten manuell wirken, und es gab keine überprüfung der Kompilierung, um die Konsistenz zu gew?hrleisten. Zum Beispiel:

 Listlist = new ArrayList ();
list.add ("Hallo");
String s = (String) list.get (0); // erfordert Casting

Wenn ein falscher Typ hinzugefügt wurde (wie eine Integer ), kann eine ClassCastException zur Laufzeit auftreten.

Mit Generics k?nnen Sie den Typ angeben, den die Sammlung enthalten sollte:

 Liste <String> list = new ArrayList <> ();
list.add ("Hallo");
String S = list.get (0); // kein Casting ben?tigt

Jetzt stellt der Compiler sicher, dass nur String -Objekte hinzugefügt werden k?nnen, und Sie erhalten die Sicherheitstypsicherheit ohne explizites Casting.

Wie Generika funktionieren

Sie definieren einen Generikum mit Angle Brackets <T> , wobei T für "Typ" steht (aber Sie k?nnen eine gültige Bezeichnung verwenden). Zum Beispiel:

 ?ffentliche Klassenbox <t> {
    privater t -Wert;

    public void set (t value) {
        this.Value = Wert;
    }

    public t Get () {
        Rückgabewert;
    }
}

Hier ist T ein Typparameter. Wenn Sie ein Box erstellen, geben Sie den tats?chlichen Typ an:

 Box <string> stringbox = neues kasten <> ();
StringBox.set ("Hallo");

Box <Ganzzahl> intbox = new Box <> ();
intbox.set (42);

Schlüsselvorteile

• Geben Sie Sicherheit ein : Fehler werden zur Kompilierungszeit anstelle der Laufzeit erfasst.
• Beseitigung des Casting : Keine Notwendigkeit, Objekte beim Abrufen zu gie?en.
• Wiederverwendbarkeit von Code : Eine generische Klasse kann mit vielen Typen funktionieren.

Gemeinsame generische Typen

Javas Sammlungsrahmen nutzt die Generika stark:

• List<T>
• Set<T>
• Map<K, V>
• Queue<T>

Sie k?nnen auch Grenztypparameter verwenden, um die verwendeten Typen einzuschr?nken:

 public <t erweitert die Zahl> Doppelsumme (t a, t b) {
    return a.doubleValue () B. doubleValue ();
}

Diese Methode akzeptiert nur Typen, die Number sind.

Typlase

Ein wichtiges Konzept für Generika ist das Typ -L?schen . W?hrend der Zusammenstellung werden generische Typinformationen entfernt (gel?scht) und durch Rohtypen (z. B. Object oder den gebundenen Typ) ersetzt. Dies bedeutet, dass zur Laufzeit eine List<String> und eine List<Integer> nur List werden. Dies geschah für die Rückw?rtskompatibilit?t mit ?lteren Java -Versionen.

Zum Beispiel:

 List <String> Strings = New ArrayList <> ();
List <Ganzzahl> ints = new ArrayList <> ();

System.out.println (Strings.getClass () == ints.getClass ()); // WAHR

Dies bedeutet auch, dass Sie einen generischen Typ nicht direkt instanziieren k?nnen:

 ?ffentliche Klassencontainer <t> {
    // t item = new t (); // nicht erlaubt - T wird zur Laufzeit gel?scht
}

Wildcards in Generika

Generika unterstützen Wildcards ( ? ), Um flexible Subtypen zu erm?glichen:

• <?> - Unbekannter Typ
• <? extends T> - Jeder Typ, der T oder eine Unterklasse von T ist
• <? super T> - Jeder Typ, der T oder eine Superklasse von T ist

Beispiel:

 public static void printNumbers (Liste <? Erweitert Nummer> Liste) {
    für (Nummer n: Liste) {
        System.out.println (n);
    }
}

Diese Methode kann List<integer></integer> , List<double></double> usw. akzeptieren.

Grunds?tzlich machen Generika Ihren Code sicherer, sauberer und wiederverwendbarer, indem Sie flexible, aber type-sichere Komponenten schreiben k?nnen.

Das obige ist der detaillierte Inhalt vonWas ist das Konzept der Generika in Java?. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!