Generics: Wildcard ?

Hi,

Generics sind eine gutes Mittel um dem Compiler Typinformationen zu liefern.
Aber was soll dann der Wildcard <?>?

Dann kann man es doch gleich sein lassen und komplett auf Generics verzichten.
 
Ohne Generics ist es ein Raw-Type, und damit werden alle Generics des Objects ignoriert, auch die, die vom Wildcard nicht betroffen sind.

Java:
class GenericsTest<T> {
    public void doSomething(List<String> strings) {
    }
}


GenericsTest<?> wildcard = new GenericsTest<>();
wildcard.doSomething(Arrays.asList(1, 2, 3)); // kompiliert nicht

GenericsTest raw = new GenericsTest<>();
raw.doSomething(Arrays.asList(1, 2, 3)); // kompiliert
 
Noch deutlicher wird das so:
Java:
class GenericsTest {
    public void doSomething1(List p) {}
    public void doSomething2(List<Object> p) {}
    public void doSomething3(List<?> p) {}
}
Bei doSomething1 können beliebige Listen übergeben werden: keine Typsicherheit
Bei doSomething2 können generische Listen, die mit dem Typ Object parametrisiert wurde, übergeben werden. Das bietet zwar Typsicherheit, funktioniert aber nur, wenn die Liste tatsächlich mit Object parametrisiert wurde; ein List<String> kann also nicht verwendet werden.
Bei doSomething3 wird eine Liste, die mit einem beliebigen (auch ohne) Typ parametrisiert wurde, erwartet. Es können z. B. sowohl List, List<Object> als auch List<String> übergeben werden.

Hinzuzufügen wäre noch, dass der Raw-Type, aus Gründen der Kompatibilität mit altem Code, auch im Fall von doSomething2 eingesetzt werden kann - man erhält dann eine entsprechende Warnung.

Hier handelt es sich um eine unbeschränkte Wildcard. Interessant wird es, wenn man diese weiter beschränkt, z. B. nach oben
Java:
    public void doSomething3(List<? extends Runnable> p) {}
In dem Fall führt die Verwendung des Raw-Types ebenfalls zu einer Warnung. Bei generischen Typen können jetzt nur noch solche verwendet werden, deren Parameter von Runnable abgeleitet ist.
 
Zuletzt bearbeitet:
Weiteres Beispiel:
Java:
public static void addStringToRawList(List list) {
  list.add("Hello"); // <- kompiliert.
}
public static void addStringToWildcardList(List<?> list) {
  list.add("Hello"); // <- kompiliert nicht!
}
Letztere Methode kompiliert nicht, weil eben nicht bekannt ist, dass es sich bei dem konkreten Typ in jedem Call der Methode um eine List<String> handelt. Es kann jeder beliebige Typ sein. Der wichtige Unterschied zu dem Raw-Type ist aber: Es ist ein "bestimmter Typ" und nicht "jeder beliebige Typ".
 
Es hilft, zu gucken, auf welcher Seite einer potenziellen Zuweisung der `?`-Typ steht. Dann wird es sehr einleuchtend. Die Buchreihe "Effective Java" redet hier zum Beispiel von "consume" vs. "produce" (und wenn wir später bei dem Thema "extends" vs. "super" ankommen, gibt es PECS - "Producer Extends, Consumer Super").
Ist ein generischer Typ ein Konsument oder ein Produzent?
Beispiele für einen Konsumenten sind, wenn der generische Typ auf der linken Seite einer potenziellen Zuweisung steht. So z.B. auch bei List.add(...). Hier findet eine Zuweisung eines aktuellen Argumentes auf den Parameter der generischen List.add(T) Methode statt. Das heißt, das T steht auf der linken Seite einer Zuweisung.
Ein Beispiel für einen Produzenten ist z.B. List.get(int). Ein solcher Ausdruck kann nur auf der rechten Seite einer Zuweisung stehen. Das heißt, das T steht auf der rechten Seite.
Jetzt muss man nur noch in die Erinnerung rufen, was Zuweisungskompatibilität in Java bedeutet. `P = S` bei Referenztypen geht nur dann, wenn `P` entweder derselbe Typ wie `S` oder ein Supertyp von `S` ist.
Und bei `?` kann man nur die Aussage treffen, dass ? von `java.lang.Object` erbt. Mehr geht nicht. Da man aber nicht weiß, welcher konkrete Typ `?` jetzt sein soll, sind Zuweisungen auf `?` nie erlaubt (generischer Typ steht auf linker Seite einer Zuweisung - er ist also Produzent - außer Zuweisungen mit `null`), wohl aber Zuweisungen der Art `Object = ?` (da `?` ja mindestens mal `java.lang.Object` sein muss).
 
warum den den extra Aufwand mit den Generics wenn das keinen Vorteil gegenüber doSomething1(List) bringt?
Richte mal Dein Augenmerk auf die Methoden selbst und nicht auf den Aufruf der Methoden.

In doSomething3 wird mit einer generischen Liste beliebigen aber unbekannten Typs gearbeitet. D. h. Du kannst in der Methode nicht beliebige Objekte zur Liste hinzufügen, da der Typ der Liste nicht bekannt ist. In doSomething1 geht das dagegen schon, da die Liste aus Object-Instanzen besteht.
 
K

kneitzel

So ganz habe ich das noch nicht verstanden. Außer dass das ? wohl nichts erlaubt.
Ich lese mir aber nicht 352 Seiten durch, um dann festzustellen dass diese keinen Mehrwert für irgendwem hätten.
Du musst ja auch nicht alle Seiten lesen. Aber aus der ersten Antwort würde ich entnehmen, dass zumindest Teilbereiche durchaus einen Wert (gehabt) haben könnten für Dich (Mehrwert benötigt einen Bezug. Mehr bezüglich was?).

Ansonsten gebe ich Dir in so fern Recht, dass es mir auch zu umfangreich beschrieben ist. Ich liebe es auch kürzer und prägnanter, wenn ich mir etwas erarbeite. Da habe ich Dinge lieber ganz kurz umrissen und wenn es nicht reicht, dann nehme ich eine weitere Quelle hinzu. Aber mir ist klar, dass weniger versierte Leute dies nicht so handhaben (können/wollen).
 
Ne Merhwert war vielleicht das falsche Wort. Aber wenn ich Seite um Seite lese und nicht viel Neues dabei lerne, dann ist das für mich nicht so "nützlich". Das meinte ich damit. Und ich weiß auch gar nicht so genau wie man so viel dazu schreiben kann.
 
Passende Stellenanzeigen aus deiner Region:

Neue Themen

Oben