Eine Einführung:
Vor der Javase 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.
2. Generische Parameter:
Klasse gen <t> {private t ob; // Definieren Sie die Variable der generischen Mitgliedsvariable public gen (t ob) {this.ob = ob;} public t getOb () {return ob;} public void setOb (t OB) {this.ob = ob;} public void spo.type () {system.out.println ("Das tatsächliche Typ. Klasse GenericParameter {public static void main (String [] args) {// Definieren einer Integer -Version der generischen Klasse Gen Gen <Integer> intob = new Gen <Integer> (100); intob.showtype (); int i = intob.getOB (); i); System.out.println ("-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------- ----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------. Ausgabe:
Die tatsächliche Art von T ist: java.lang.Integer
Wert = 100
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Die tatsächliche Art von T ist: Java.lang.String
Wert = Hallo Dylan!
3. Generika:
class Genericsfoo <t> {private t x; public Genericsfoo (t x) {this.x = x;} public t getX () {return x;} public void setx (t x) {this.x = x;}} public class genericClass {public static void main (String args []) {negreefoo <Strafoo <sting> static -static void main (String args []) {genericsfoo <sting> <Strafoo = Stripoo = static genou (helly "{genericsfoo <straße> stratesfoo = static genou Generics! "); Genericsfoo <Double> Doufoo = New Genericsfoo <Double> (neues Double (" 33 "); Genericsfoo <Object> objfoo = new Genericsfoo <Object> (neu Object ()); system.out.println ("strfoo.getX ="+strfoo.getX ()); Ausgabe:
strfoo.getX = Hallo Generika!
Doufoo.getX = 33.0
objfoo.getX=java.lang.object@1d0fafc
Vier begrenzte Generika:
import java.util.ArrayList;import java.util.Collection;class CollectionGenFoo<T extends Collection> {private T x;public CollectionGenFoo(T x) {this.x = x;}public T getX() {return x;}public void setX(T x) {this.x = x;}}public class GenericRestrict {public static void main(String[] args) {CollectionGenfoo <ArrayList> listfoo = null; listfoo = new CollectionGenfoo <ArrayList> (new ArrayList ()); CollectionGenfoo <? Erweitert die Sammlung> listfoo1 = null; listfoo1 = new CollectionGenfoo <ArrayList> (new ArrayList ()); System.out.println ("Instanziierung erfolgreich!");}} Ausgabe:
Instanziierung war erfolgreich!
Fünf generische Methoden:
public class genericFunction {public <t> void f (t x) {System.out.println (x.getClass (). getName ());} public static void main (String [] args) {GenericFunction Ea = new genericfunction (); Ausgabe:
Java.lang.String
Java.lang.Integer
java.lang.character
Generikfunktion
---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
Dylan präsentiert.
Zusammenfassen
Das obige ist der gesamte Inhalt dieses Artikels über die detaillierte Erklärung generischer Beispiele in Java. Ich hoffe, es wird für alle hilfreich sein. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!