Generika – Einführung in Generika

Einführung in Generika

Nehmen wir ein Beispiel, um zu veranschaulichen, was Generika sind.
Es gibt zwei Klassen wie folgt. Es ist notwendig, Objekte der beiden Klassen zu erstellen und ihre jeweiligen Mitglieder x auszudrucken.
public class StringFoo {
private String x;
public String getX() {
return x
}

public void setX(String x) {
this.x = x;
}

public class DoubleFoo {
public Double getX() {
return x; 🎜> public void setX(Double x) {
this.x = x; Der entsprechende Unterricht ist wirklich langweilig.
Umgestalten Sie daher die beiden oben genannten Klassen in eine Klasse und beachten Sie Folgendes:
In der obigen Klasse ist die Logik der Mitglieder und Methoden dieselbe, die Typen sind jedoch unterschiedlich. Object ist die übergeordnete Klasse aller Klassen. Sie können daher die Verwendung von Object als Mitgliedstyp in Betracht ziehen, damit es universell ist.
public class ObjectFoo {
private Object x;
public Object getX() {
return x
}

public void setX(Object x) {
this.x = x;
}
} Der von

aufgerufene Code lautet wie folgt:
public class ObjectFooDemo {
public static void main(String args[]) {
ObjectFoo strFoo = new ObjectFoo();
strFoo.setX("Hallo Generics!");
ObjectFoo douFoo = new ObjectFoo();
douFoo.setX(new Double("33")) ;
ObjectFoo objFoo = new ObjectFoo();
objFoo.setX(new Object()); Double)dou Foo .getX();
Object obj = objFoo.getX();

System.out.println("strFoo.getX=" + str); ;
System.out.println("strFoo.getX=" + obj); }
}
Das Obige ist, was wir ohne Generika schreiben. Der Code verwendet die Basisklasse Object der obersten Ebene Typdeklaration, übergibt dann den Wert und führt beim Herausnehmen eine erzwungene Typkonvertierung durch.
JDK hat seit 1.5 das Konzept der Generika eingeführt, um solche Probleme elegant zu lösen. Unter Verwendung generischer Technologie lautet der geschriebene Code wie folgt:
public class GenericsFoo {
private T x() {
return x; >
public void setX(T x) {
this.x = x; }
}

Der aufrufende Code lautet wie folgt:
public class GenericsFooDemo {
public static void main(String args[]){
GenericsFoo();
strFoo.setX("Hallo Generics!"); ; douFoo= new GenericsFoo();
douFoo.setX(new Double("33");
Object( )); 🎜> Double d = douFoo.getX();
Object obj = objFoo.getX();
System.out.println("strFoo.getX=" + obj); }
}

Beachten Sie, dass es mehrere offensichtliche Änderungen gibt:
1. Beim Erstellen des Objekts muss der Typ explizit angegeben werden, z. B. GenericsFoo.
2． Wenn das Objekt über die getX-Methode abgerufen wird, ist keine Typkonvertierung erforderlich.
3. Wenn beim Aufruf jeder Methode der Parametertyp nicht mit dem beim Erstellen der Methode angegebenen Typ übereinstimmt, meldet der Compiler einen Fehler.
Warum brauchen wir also Generika? Es gibt zwei Vorteile:
1. Sie können zum Zeitpunkt der Kompilierung überprüfen, ob die gespeicherten Daten korrekt sind. In unserer Entwicklung besteht die Tendenz, Fehler so früh wie möglich zu finden, vorzugsweise während der Kompilierungsphase. Generika erfüllen gerade diese Bedingung.
2. Reduziert die erzwungene Konvertierung, String str = (String)strList.get(0); eine solche Operation ist eine relativ gefährliche Operation, wenn das in der Liste gespeicherte Objekt nicht für String geeignet ist. es wird eine Ausnahme auslösen.
In JDK1.5 unterstützen verschiedene Datentyp-Toolklassen im Paket java.util Generika, die in der Programmierung weit verbreitet sind und beherrscht werden müssen.
Die häufigsten Anwendungen von Generika sind Klassen, Schnittstellen und Methoden, die im Folgenden vorgestellt werden.
3.4.2 Generics werden auf Schnittstellen angewendet:
public interface ValuePair ;
}
Hier repräsentieren A und B beide Typen. In cusp <> können Sie einen Typ oder mehrere Typen verwenden.
3.4.3 Generics werden auf Klassen angewendet:
public class ValuePairImpl b) { first = a; second = b }
public A getA() { return first; }
public String toString() {
Return „(“ + first + „, „ + second + „)“; ,B> implementiert ValuePair .getName() + „ = „ + v.toString();          System.out.println(str); Natürlich kann der Rückgabewert auch ein generischer Typ sein.
3.4.5 Beschränkung der verfügbaren generischen Typen
Die drei oben vorgestellten generischen Anwendungen werden auf Schnittstellen, Klassen und Methoden angewendet. Sie sind ein gängiger Ansatz und unterliegen keinen Einschränkungen hinsichtlich der Typen, die übergeben werden können auf Generika beschränken. In einigen Szenarien möchten wir jedoch die verfügbaren Typen einschränken. Wir hoffen beispielsweise, dass der eingehende Typ von einer bestimmten Klasse erben muss (dh es muss eine Unterklasse, ein Enkel usw. einer bestimmten Klasse sein). In diesem Fall wird die generische Einschränkungssyntax verwendet.
extends: Beschränken Sie generische Typen auf die Nachkommen einer bestimmten Klasse, einschließlich dieses Typs.
Syntax:
Hier ist T ein generischer Typ und das Schlüsselwort „extens“ beschränkt den generischen Typ darauf, ein Nachkomme von parentClass zu sein. parentClass gibt den Typ der übergeordneten Klasse an, die auch eine Schnittstelle sein kann.
In der Java-Sprache können Klassen nur einzeln geerbt werden, und Schnittstellen können mehrfach geerbt werden. Wenn Sie einen bestimmten Typ darauf beschränken möchten, von einer bestimmten Klasse zu erben und mehrere Schnittstellen zu implementieren, lautet die Syntax:
< ;T erweitert parentClass & parentInterface1 & parentInterface2>
Beachten Sie, dass die Klasse vor der Schnittstelle stehen muss.
Ein Beispiel ist wie folgt:
öffentliche Klasse BaseClass {
       int-Wert; 

       public BaseClass(int value) { 
              this.value = value; 
       } 
       
       public int getValue() { 
              Rückgabewert; 
       } 

       public void setValue(int value) { 
              this.value = value; 
       } 
       
} 

public class SubClass erweitert BaseClass{ 
       public SubClass(int value) { 
              super(value*2); 
       } 
} 

öffentliche Klasse GenericBound { 
       
       public long sum(List tList) { 
              long iValue = 0; 
              for (BaseClass base : tList) { 
                     iValue += base.getValue(); 
              } 
              
              return iValue; 
       } 

       public static void main(String[] args) { 
              GenericBound obj = new 
GenericBound(); 
              
              List list = new LinkedList(); 
              list.add(new SubClass(5)); 
              list.add(new SubClass(6)); 
              
              System.out.println(obj.sum(list)); 
       } 
} 
运行，输出结果为22. 
接着，我们再深入探讨一下。把上面的例子该写如下: 
public class GenericBound { 
       
       public long sum(List tList) { 
              long iValue = 0; 
              for (BaseClass base : tList) { 
                     iValue += base.getValue(); 
              } 
              
              return iValue; 
       } 

       public static void main(String[] args) { 
              // 注意！！！ 
              // 将obj 的类型由GenericBound oder GenericBound ，无法通过编译 
              GenericBound obj = new 
GenericBound(); 
              
List list = new LinkedList();
list.add(new SubClass(6)); (obj.sum(list));
}  
}
Die Anweisung GenericBound(); kann die Kompilierung nicht bestehen schränkt T beim Erstellen dieses Instanztyps auf einen bestimmten Typ ein, und dieser Typ ist ein Nachkomme von BaseClass. Es gibt jedoch viele Nachkommen von BaseClass, z. B. SubClass3 und SubClass4. Wenn Sie für jede einen bestimmten Unterklassentyp schreiben müssen, ist es besser, Object zum Verallgemeinern zu verwenden. Können wir den Typ der übergeordneten Klasse verwenden, um Instanzen verschiedener Unterklassen wie gewöhnliche Klassen einzuführen? Wäre das nicht viel einfacher? Die Antwort lautet „Ja“. Eine bessere Lösung für diese Situation sind „Wildcard-Generika“, die weiter unten ausführlich erläutert werden.
3.4.6 Wildcard-Generika
Die generischen Typen von Java sind gewöhnliche Java-Typen wie java.lang.String und java.io.File. Beispielsweise unterscheiden sich die Typen der folgenden beiden Variablen:
Box