Lors de l'utilisation de méthodes génériques et quand utiliser la wild-card?

Il ya certains endroits, où les caractères génériques, paramètres de type et de faire la même chose. Mais il y a aussi certains endroits, où vous devez utiliser les paramètres de type.

1. Si vous souhaitez mettre en place des relations sur les différents types d'arguments de méthode, vous ne pouvez pas le faire avec des caractères génériques, vous devez utiliser les paramètres de type.

De prendre votre méthode à titre d'exemple, supposons que vous voulez vous assurer que le src et dest liste transmise à copy() méthode doit être de même type paramétré, vous pouvez le faire avec des paramètres de type de la sorte:

public static <T extends Number> void copy(List<T> dest, List<T> src)

Ici, vous êtes assuré que les deux dest et src ont le même type paramétré pour List. Donc, il est sûr de copier des éléments d' src à dest.

Mais, si vous passez à changer la méthode à utiliser générique:

public static void copy(List<? extends Number> dest, List<? extends Number> src)

il ne fonctionne pas comme prévu. Dans le 2ème cas, vous pouvez passer List<Integer> et List<Float> comme dest et src. Ainsi, en déplaçant les éléments de src à dest ne serait pas le type est plus sûr.
Si vous n'avez pas besoin de ce genre de relation, alors vous êtes libre de ne pas utiliser les paramètres de type à tous.

Une autre différence entre l'utilisation de caractères génériques et le type des paramètres sont:

• Si vous avez un seul paramétrée type d'argument, alors vous pouvez utiliser des caractères génériques, bien que le paramètre de type fonctionnera également.
• Les paramètres de Type de support de multiples limites, les caractères génériques ne sont pas.

• Jokers soutenir à la fois les limites supérieures et inférieures, les paramètres de type, en plus de soutenir les limites supérieures. Donc, si vous voulez définir une méthode qui prend un List de type Integer ou c'est super classe, vous pouvez faire:

  public void print(List<? super Integer> list)  //OK

  mais vous ne pouvez pas utiliser les paramètres de type:

   public <T super Integer> void print(List<T> list)  //Won't compile

---

Références:

• Angelika Langer Java Génériques Faq

À votre première question: Cela signifie que si il y a une relation entre le paramètre du type et de la méthode de retour de ce type, alors l'utilisation d'un générique.

Par exemple:

public <T> T giveMeMaximum(Collection<T> items);
public <T> Collection<T> applyFilter(Collection<T> items);

Ici, vous êtes à l'extraction de certains de la T à la suite d'un certain nombre de critères. Si T est Long vos méthodes sera de retour Long et Collection<Long>; le type de retour est dépendante du type de paramètre, il est donc utile, et conseillé, de l'utilisation des types génériques.

Quand ce n'est pas le cas, vous pouvez utiliser les types de cartes:

public int count(Collection<?> items);
public boolean containsDuplicate(Collection<?> items);

Dans cet exemple deux quel que soit le type des éléments dans les collections les types de retour sera int et boolean.

Dans votre exemple:

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

ces deux fonctions retournent un booléen quel que soit les types des objets dans les collections. Dans le second cas, elle est limitée à des instances d'une sous-classe de E.

Deuxième question:

class Collections {
    public static <T> void copy(List<T> dest, List<? extends T> src) {
    ...
}

Ce premier code vous permettent de passer d'une hétérogènes List<? extends T> src en tant que paramètre. Cette liste peut contenir plusieurs éléments de différentes classes aussi longtemps que ils ont tous étend la classe de base T.

si vous avez eu:

interface Fruit{}

et

class Apple implements Fruit{}
class Pear implements Fruit{}
class Tomato implements Fruit{}

vous pourriez faire

List<? extends Fruit> basket = new ArrayList<? extends Fruit>();
basket.add(new Apple());
basket.add(new Pear());
basket.add(new Tomato());
List<Fruit> fridge = new ArrayList<Fruit>(); 

Collections.copy(fridge, basket);//works 

D'autre part

class Collections {
    public static <T, S extends T> void copy(List<T> dest, List<S> src) {
    ...
}

contraindre List<S> src à être de un particulier de la classe S, qui est une sous-classe de T. La liste ne peut contenir que des éléments d'une classe (dans ce cas, S) et aucune autre classe, même s'ils mettent en œuvre des T trop. Vous ne seriez pas en mesure d'utiliser mon exemple précédent, mais vous pouvez faire:

List<Apple> basket = new ArrayList<Apple>();
basket.add(new Apple());
basket.add(new Apple());
basket.add(new Apple());
List<Fruit> fridge = new ArrayList<Fruit>();

Collections.copy(fridge, basket); /* works since the basket is defined as a List of apples and not a list of some fruits. */

Je vais essayer de répondre à votre question, un par un.

Ne pensons-nous pas à une wild-card comme (Collection<? extends E> c); est également
soutien type de polymorphisme?

Pas. La raison en est que la délimitée générique n'a pas défini le type de paramètre. Il est un inconnu. Tous il "sait", c'est que le "confinement" est d'un type E (quelle que soit défini). Donc, il ne peut pas vérifier et de justifier si la valeur fournie correspond à la délimitée type.

Donc, il n'est pas judicieux d'avoir polymorphes comportements sur des caractères génériques.

Le document décourage la deuxième déclaration et favorise l'utilisation de
la première syntaxe? Quelle est la différence entre la première et la deuxième
déclaration? Les deux semble être en train de faire la même chose?

La première option est préférable dans ce cas que T est toujours borné, et source va certainement avoir des valeurs (des inconnus) que les sous-classes T.

Donc, supposons que vous souhaitez copier tous les liste de nombres, la première option sera

Collections.copy(List<Number> dest, List<? extends Number> src);

src, essentiellement, peut accepter List<Double>, List<Float>, etc. comme il existe une limite supérieure à la paramétrée type trouvé dans dest.

La 2ème option va vous forcer à se lier S pour chaque type que vous souhaitez copier, comme

//For double 
Collections.copy(List<Number> dest, List<Double> src); //Double extends Number.

//For int
Collections.copy(List<Number> dest, List<Integer> src); //Integer extends Number.

Comme S est paramétrée type qui a besoin de liaison.

J'espère que cette aide.

Comme je le comprends, il y a un seul cas d'utilisation lorsque le générique est strictement nécessaire (c'est à dire peut exprimer quelque chose que vous ne pouvez pas l'exprimer avec des paramètres de type). C'est quand vous avez besoin de spécifier une limite inférieure.

En dehors de cela cependant des caractères génériques servent à écrire plus de code concis, comme indiqué par les instructions suivantes dans le document que vous mentionnez:

Méthodes génériques permettent de paramètres de type à être utilisé pour exprimer
les dépendances entre les types d'un ou de plusieurs arguments pour une méthode
et/ou son type de retour. Si il n'y a pas une dépendance, un générique
la méthode ne doit pas être utilisé.

[...]

À l'aide de caractères génériques est plus clair et plus concis que de déclarer explicite
les paramètres de type, et devrait donc être privilégiée chaque fois que possible.

[...]

Des caractères génériques ont aussi l'avantage qu'ils peuvent être utilisés à l'extérieur de
signatures de méthode, comme les types de champs, variables locales et les tableaux.