Warum ist List <Number> kein Untertyp der List <Object

Überlegen Sie, ob es war ...

List<Integer> nums = new ArrayList<Integer>();
List<Object> objs = nums
objs.add("Oh no!");
int x = nums.get(0); //throws ClassCastException

Sie würden der Lage, etwas von der Muttertyp zu der Liste hinzufügen, die möglicherweise nicht, was es früher erklärt wurde, das als das obige Beispiel zeigt, alle möglichen Probleme verursacht. Somit ist es nicht erlaubt.

Sie sind nicht Subtypen voneinander durch, wie Generika Arbeit. Was Sie wollen, ist Ihre Funktion wie folgt zu erklären:

public void wahey(List<?> list) {}

Dann wird es eine Liste der alles akzeptieren, die Gegenstand erstreckt. Sie können auch tun:

public void wahey(List<? extends Number> list) {}

So können Sie in Listen von etwas nehmen, die eine Unterklasse von Nummer ist.

Ich würde empfehlen, eine Kopie von "Java Generics und Sammlungen" Pick up von Maurice Naftalin & Philip Wadler.

Es gibt im Wesentlichen zwei Dimensionen der Abstraktion hier die Liste Abstraktion und die Abstraktion seines Inhalts. Es ist völlig in Ordnung entlang der Liste Abstraktion variieren - zu sagen, zum Beispiel, dass es ein LinkedList oder eine Arraylist - aber es ist nicht in Ordnung weiter den Inhalt zu beschränken, zu sagen: Diese (Liste der Objekte enthält) ist eine (verkettete Liste der hält nur Zahlen). Da jede Referenz, die es als eine (Liste der Objekte enthält) weiß, versteht, durch den Vertrag seiner Art, dass es halten kann jeder Objekt.

Das ist ganz anders, als man in der Nicht-Generika-Beispiel-Code getan haben, wo Sie gesagt haben: diese String behandeln, als ob es sich um eine Doppel waren. Sie versuchen, anstatt zu sagen: diese (Liste, die nur Zahlen hält) zu behandeln als (Liste, die alles hält). Und dies nicht der Fall, und der Compiler kann es erkennen, so dass es nicht Sie nicht mit ihm durchgehen lassen.

"Was wir hier machen, ist im Wesentlichen das gleiche, außer dies wird vorübergehen Kompilierung-Kontrollen und nur scheitern an Laufzeit. Die Version mit Listen nicht kompilieren. "

Was Sie beobachten macht Sinn, wenn man bedenkt, dass der Hauptzweck der Java Generics ist, um Typ-Inkompatibilitäten versagen bei der Kompilierung statt Laufzeit zu bekommen.

java.sun.com

Generics bietet eine Möglichkeit für Sie den Typ einer Sammlung kommunizieren so an den Compiler, dass es sein kann, geprüft. Sobald der Compiler kennt die Elementart der Erhebung, die Compiler können überprüfen, ob Sie verwendet haben die Sammlung konsequent und kann Fügen Sie die richtigen Würfe auf Werte wobei aus der Sammlung genommen.

In Java List<S> nicht ein Subtyp von List<T> wenn S ein Subtyp von T ist. Diese Regel stellt Typsicherheit.

Nehmen wir an, wir zulassen, dass ein List<String> ein Subtyp von List<Object> sein. Betrachten Sie das folgende Beispiel:

public void foo(List<Object> objects) {
    objects.add(new Integer(42));
}

List<String> strings = new ArrayList<String>();
strings.add("my string");
foo(strings); // this is not allow in java
// now strings has a string and an integer!
// what would happen if we do the following...??
String myString = strings.get(1);

Also, das zwingt bietet Sicherheit geben, aber es hat auch einen Nachteil, es ist weniger flexibel. Betrachten Sie das folgende Beispiel:

class MyCollection<T> {
    public void addAll(Collection<T> otherCollection) {
        ...
    }
}

Hier finden Sie eine Sammlung von T die haben, möchten Sie alle Artikel aus einer anderen Sammlung hinzuzufügen. Sie können diese Methode nicht aufrufen mit einem Collection<S> für einen S Subtyp von T. Idealerweise ist dies in Ordnung, weil Sie nur Elemente in Ihre Sammlung hinzugefügt werden, sind Sie nicht die Parametersammlung ändern.

Um dies zu beheben, bietet Java, was sie „Platzhalter“ nennen. Wildcards sind eine Möglichkeit, Kovarianz / Kontra bereitzustellen. Betrachten wir nun die folgenden mit Wildcards:

class MyCollection<T> {
     // Now we allow all types S that are a subtype of T
     public void addAll(Collection<? extends T> otherCollection) {
         ...

         otherCollection.add(new S()); // ERROR! not allowed (Here S is a subtype of T)
     }
}

Jetzt, mit Wildcards wir Kovarianz in der Art T erlauben und wir blockieren Operationen, die nicht typsicher sind (beispielsweise ein Element in der Sammlung hinzufügen). Auf diese Weise erhalten wir die Flexibilität und Typsicherheit.