Die umfassendste Zusammenfassung der generischen Java-Programmierung

1 Einführung

Die generische Java-Programmierung wurde nach der JDK1.5-Version eingeführt. Generics ermöglichen Programmierern die Verwendung von Typabstraktionen, häufig innerhalb von Sammlungen. Das Folgende ist ein Beispiel für die Nichtverwendung von Generika:

List myIntList=new LinkedList(); //1  
myIntList.add(newInteger(0)); //2  
Integer x=(Integer)myIntList.iterator().next(); //3

Achten Sie auf die dritte Codezeile, aber das ist ein sehr unangenehmer Punkt, da der Programmierer wissen muss, welche Art von Objekt in der Liste gespeichert ist ist eine Ganzzahl, aber wenn Elemente in einer Liste zurückgegeben werden, muss der Typ trotzdem umgewandelt werden. Warum ist das so? Der Grund dafür ist, dass der Compiler nur sicherstellen kann, dass die next()-Methode des Iterators ein Objekt vom Typ Object zurückgibt. Um die Typsicherheit der Integer-Variablen zu gewährleisten, muss eine Konvertierung erzwungen werden.

Diese Art der Konvertierung ist nicht nur verwirrend, sondern kann auch zu einer Typkonvertierungsausnahme führen. ClassCastException ist oft schwer zu erkennen. Stellen Sie sicher, dass die Elemente in der Liste einen bestimmten Datentyp haben, damit die Typkonvertierung abgebrochen werden kann, wodurch die Wahrscheinlichkeit von Fehlern verringert wird. Dies ist auch die ursprüngliche Absicht des generischen Designs. Das Folgende ist ein Beispiel für die Verwendung von Generika:

List<Integer> myIntList=newLinkedList<Integer>(); //1’  
myIntList.add(newInteger(0)); //2’  
Integerx=myIntList.iterator().next(); //3’

Geben Sie in der ersten Codezeile an, dass der in der Liste gespeicherte Objekttyp eine Ganzzahl ist, sodass beim Abrufen des nicht eine Umwandlung des Typs erforderlich ist Objekte in der Liste.

2 Definieren Sie einfache Generika

Das Folgende ist eine Definition, die aus der Schnittstelle List und Iterator im Paket java.util zitiert wird und generische Technologie verwendet.

public interface List<E> {  
<span style="white-space: pre;">    </span>void add(E x);  
<span style="white-space: pre;">    </span>Iterator<E> iterator();  
}  
public interface Iterator<E> {  
<span style="white-space: pre;">    </span>E next();  
<span style="white-space: pre;">    </span>boolean hasNext();  
}

Dies unterscheidet sich nicht vom nativen Typ, außer dass nach der Schnittstelle eine spitze Klammer hinzugefügt wird. Innerhalb der spitzen Klammer befindet sich ein Typparameter (bei der Definition handelt es sich um einen formatierten Typparameter). Wird verwendet, wenn ein konkreter Typ aufgerufen wird, um den Typ zu ersetzen.

Vielleicht können Sie es sich so vorstellen: List bedeutet, dass der Typparameter E in der Liste durch Integer ersetzt wird.

public interface IntegerList {  
<span style="white-space: pre;">    </span>void add(Integer x)  
<span style="white-space: pre;">    </span>Iterator<Integer> iterator();  
}

Typlöschung bezieht sich auf die Zuordnung generischer Typinstanzen zu demselben Bytecode durch Zusammenführen von Typparametern. Der Compiler generiert nur einen Bytecode für den generischen Typ und ordnet seine Instanzen diesem Bytecode zu, sodass statische Variablen im generischen Typ von allen Instanzen gemeinsam genutzt werden. Darüber hinaus ist zu beachten, dass eine statische Methode nicht auf die Typparameter einer generischen Klasse zugreifen kann, da die Klasse nicht instanziiert wurde. Wenn die statische Methode daher generische Funktionen verwenden muss, muss sie zu einer generischen Methode gemacht werden. Der Schlüssel zur Typlöschung besteht darin, Informationen über Typparameter aus generischen Typen zu löschen und bei Bedarf Typprüfungs- und Typkonvertierungsmethoden hinzuzufügen. Bei der Verwendung von Generika wird jeder konkrete Typ gelöscht und Sie wissen nur noch, dass Sie ein Objekt verwenden. Beispiel: List und List sind tatsächlich vom gleichen Typ. Sie werden alle in ihrem nativen Typ gelöscht, nämlich Liste. Da es während der Kompilierung zu einer Typlöschung kommt, können Methoden nicht durch Instanzen derselben generischen Klasse unterschieden werden. Im folgenden Beispiel tritt während der Kompilierung ein Fehler auf, da nach der Typlöschung beide Methoden Parameter vom Typ List sind Methoden können nicht anhand des Typs einer generischen Klasse unterschieden werden.

 public class Erasure{  
            public void test(List<String> ls){  
                System.out.println("Sting");  
            }  
            public void test(List<Integer> li){  
                System.out.println("Integer");  
            }  
  }

Es liegt also ein Problem vor, da die tatsächlichen Typinformationen in Methoden und Klassen während der Kompilierung gelöscht werden. Woher wissen Sie den spezifischen Typ, wenn Sie ein Objekt zurückgeben? Beispielsweise werden die String-Informationen von List nach der Kompilierung gelöscht. Wenn also die Objekte in der Liste zur Laufzeit durch den Iterator zurückgegeben werden, woher wissen wir, dass die in der Liste gespeicherten Objekte Objekte vom Typ String sind?

Durch das Löschen werden Typinformationen im Methodenkörper entfernt. Das Problem zur Laufzeit liegt also in den Grenzen: Wo das Objekt die Methode betritt und verlässt des Codes. Alle Aktionen in Generics erfolgen an Grenzen: Zusätzliche Überprüfungen zur Kompilierungszeit werden für die übergebenen Werte durchgeführt und Umwandlungen für die übergebenen Werte werden eingefügt.

3. Generika und Untertypen

Um Generika vollständig zu verstehen, hier ein Beispiel: (Apple ist eine Unterklasse von Fruit

List<Apple> apples = new ArrayList<Apple>(); //1  
List<Fruit> fruits = apples; //2

第1行代码显然是对的，但是第2行是否对呢？我们知道Fruit fruit = new Apple()，这样肯定是对的，即苹果肯定是水果，但是第2行在编译的时候会出错。这会让人比较纳闷的是一个苹果是水果，为什么一箱苹果就不是一箱水果了呢？可以这样考虑，我们假定第2行代码没有问题，那么我们可以使用语句fruits.add(new Strawberry())（Strawberry为Fruit的子类）在fruits中加入草莓了，但是这样的话，一个List中装入了各种不同类型的子类水果，这显然是不可以的，因为我们在取出List中的水果对象时，就分不清楚到底该转型为苹果还是草莓了。

通常来说，如果Foo是Bar的子类型，G是一种带泛型的类型，则G不是G的子类型。这也许是泛型学习里面最让人容易混淆的一点。

4.通配符

4.1通配符？

先看一个打印集合中所有元素的代码。

void printCollection(Collection c) {                  
<span style="white-space: pre;">    </span>Iterator i=c.iterator();  
<span style="white-space: pre;">    </span>for (k=0;k < c.size();k++) {  
<span style="white-space: pre;">        </span>System.out.println(i.next());  
<span style="white-space: pre;">    </span>}  
}

void printCollection(Collection<Object> c) {  
for (Object e:c) {  
System.out.println(e);  
}  
}

很容易发现，使用泛型的版本只能接受元素类型为Object类型的集合如ArrayList