Wann sollten Platzhalter in Java Generics verwendet werden?

Den großen Unterschied zwischen

public <T extends Animal> void takeThing(ArrayList<T> list)

und

public void takeThing(ArrayList<? extends Animal> list)

ist, dass in der ehemaligen Methode finden Sie unter "T" innerhalb der Methode, wie die konkrete Klasse, die gegeben wurde. In der zweiten Methode können Sie nicht tun.

Hier ein komplexeres Beispiel um dies zu verdeutlichen:

//here i can return the concrete type that was passed in
public <T extends Animal> Map<T, String> getNamesMap(ArrayList<T> list) {
    Map<T, String> names = new HashMap<T, String>();
    for (T animal : list) {
        names.put(animal, animal.getName()); //i assume there is a getName method
    }
    return names;
}

//here i have to use general Animal
public Map<Animal, String> getNamesMap(ArrayList<? extends Animal> list) {
    Map<Animal, String> names = new HashMap<Animal, String>();
    for (Animal animal : list) {
        names.put(animal, animal.getName()); //i assume there is a getName method
    }
    return names;
}

Mit der ersten Methode, wenn Sie übergeben eine Liste von Katzen, die Sie bekommen eine Karte mit Katze als Schlüssel. Die zweite Methode würde immer wieder eine Karte mit Allgemeinen Tier Schlüssel.

Dies ist übrigens keine gültige java-syntax:

public <? extends Animal> void takeThing(ArrayList<?> list)

Verwendung dieser form der generischen Methode-Deklaration ein Gültiger java-Bezeichner sein und nicht "?".

Edit:

Form "? erstreckt Typ" gilt nur für Variablen oder parameter-Typ-Deklaration. Innerhalb einer generischen Methode declration es muss "Bezeichner erstreckt Typ", wie Sie in der Lage sind, verweisen auf die "Kennung" aus Ihrer Methode.

InformationsquelleAutor der Antwort Werzi2001

Bindung der Art an einem Typ-parameter kann leistungsfähiger sein, je nachdem, was die Methode tun soll. Ich bin mir nicht sicher, was takeThing soll das tun, aber vorstellen, im Allgemeinen haben wir eine Methode, mit der man diese Art Unterschriften:

public <T extends Animal> void foo(ArrayList<T> list);

//or

public void foo(ArrayList<? extends Animal> list);

Hier ist ein konkretes Beispiel von etwas, was Sie nur tun können, mit der ersten Typ Signatur:

public <T extends Animal> void foo(ArrayList<T> list) {
    list.add(list.remove(0)); //(cycle front element to the back)
} 

In diesem Fall T ist verpflichtet, der Typ checker, das element entfernt aus der Liste ist ein OK-element hinzufügen auf der Liste.

Könnte man dies nicht mit einem wildcard, weil, wie der Platzhalter hat, nicht gebunden an einen Typ-parameter, dessen Kontext nicht verfolgt (gut, es verfolgt wird, durch "einfangen", aber es ist nicht zu nutzen). Sie können mehr Informationen über diese in einer anderen Antwort habe ich gegeben: Wie Generika von Generika zu arbeiten?

InformationsquelleAutor der Antwort Mark Peters

Wenn Ihr takeThing - Methode benötigt, um das hinzufügen von Elementen zur list parameter, die wildcard-version nicht kompilieren.

Der interessante Fall ist, wenn Sie nicht hinzufügen, um der Liste und beide Versionen scheinen zu kompilieren und zu arbeiten.

In diesem Fall schreiben Sie die Platzhalter-version, wenn Sie möchten, dass verschiedene Art der Tiere, die in der Liste (mehr Flexibilität) und die parameter-version, wenn Sie benötigen eine Feste Art von Tier in der Liste: die T-Typ.

Beispielsweise die java.util.Collection erklärt:

interface Collection<E> {
  ...
  public boolean containsAll(Collection<?> c);
  ...
}

Und angenommen, Sie haben folgenden code:

Collection<Object> c = Arrays.<Object>asList(1, 2); 
Collection<Integer> i = Arrays.<Integer>asList(1, 2, 3); 
i.containsAll(c); //compiles and return true as expected

Wenn die java.util.Collection wäre:

interface Collection<E> {
    ...
    public boolean containsAll(Collection<E> c);
    ...
}

Den oben genannten test-code würde nicht kompilieren und die Flexibilität der Collection API reduziert werden würde.

Es erwähnenswert, dass die letztere definition von containsAll hat den Vorteil, fangen mehr Fehler zur compile-Zeit, zum Beispiel:

Collection<String> c = Arrays.asList("1", "2"); 
Collection<Integer> i = Arrays.asList(1, 2, 3); 
i.containsAll(c); //does not compile, the integer collection can't contain strings

Aber findet der gültigen test mit einem Collection<Object> c = Arrays.<Object>asList(1, 2);

InformationsquelleAutor der Antwort dcernahoschi