Quand un appel de méthode paramétré est-il utile?

Une méthode en Java appel peut être paramétrée comme dans le code suivant:

class Test
{
    <T> void test()
    {
    }

    public static void main(String[] args)
    {
        new Test().<Object>test();
        //        ^^^^^^^^
    }
}

J'ai trouvé que c'est possible à partir de l'Eclipse Java Formateur de dialogue paramètres et je me demandais si il existe tous les cas où cela est utile ou nécessaire.

MODIFIER

Basé sur Arne excellente réponse, je suis venu à la conclusion suivante:

En plus de l'amélioration de la sécurité de type comme Arne de l'illustre l'exemple paramétrée appel de méthode vous permet de spécifier la commune type de base des méthodes d'arguments qui devraient être le type de conteneur éléments. Ce type est normalement inferenced automatiquement par le compilateur pour le plus spécifique de la commune type de base. Le paramétrage de l'appel de méthode ce comportement peut être substituée. Un paramétrée à l'appel de la méthode peut être nécessaire s'il y a plusieurs types communs inferenced par le compilateur.

L'exemple suivant montre que le comportement:

import java.util.Arrays;
import java.util.List;

class Test
{
    public static void main(String[] args)
    {
        Integer a=new Integer(0);
        Long    b=new Long(0);
        List<Object> listError=Arrays.asList(a, b);
        //error because Number&Comparable<?> is not Object
        List<Object> listObj=Arrays.<Object>asList(a, b);
        List<Number> listNum=Arrays.<Number>asList(a, b);
        List<Comparable<?>> listCmp=Arrays.<Comparable<?>>asList(a, b);
    }
}

Ce comportement est défini dans Le Langage Java Spécification de la Troisième Édition des paragraphes 8.4.4 et 15.12.2.7 mais pas facile à comprendre.

source d'informationauteur Johann-Christoph Jacob

14

Je n'ai jamais utilisé ce dans la pratique, mais vous pouvez vous imaginer l'utiliser pour le type de sécurité. Considérons la méthode suivante:
```
<T> void method(T... items) {
    List<T> list = new ArrayList<T>();
    for (T item : items)
        list.add(item);
    System.out.println(list);
}
```
Vous pouvez l'appeler de cette façon:
```
o.<Object>method("Blah", new Long(0));
o.<Number>method(new Integer(100), new Long(0));
```
Mais cela génère une erreur de compilation:
```
o.<Number>method("String", new Long(0));
```
Si vous avez une méthode générique qui est typesafe et peut être utilisé pour chaque Objet, et non pas limitée à une interface spécifique ou de la classe.
13

Paramétré les appels de méthode sont utiles lorsque vous souhaitez permettre à différents types sans moulage. Par exemple, le Collections de la classe helper fait un large usage de paramétrées appels de méthode. Lorsque vous voulez procéder à un nouveau générique de la collection à l'aide de l'un de leurs méthodes d'assistance, quelques exemples:
```
List<String> anEmptyStringList = Collections.<String>emptyList();
Set<Integer> unmodifiableCopy = Collections.<Integer>unmodifiableSet(originalSet);
```
Donc, quand vous voulez être en mesure d'utiliser le type générique ailleurs, vous souhaitez utiliser ces appels de méthode. Ils empêchent les avertissements du compilateur lors de l'utilisation de médicaments génériques.
8

Il est sans doute plus utile lorsque vous prenez une collection d'un certain type, et le retour de certains sous-ensemble de la collection.
```
<T> List<T> filter(Collection<? extends T> coll, Predicate<? super T> pred) {
    List<T> returnList = new ArrayList<T>();
    for(T t : coll) {
        if(pred.matches(t)){
            returnList.add(t);
        }
    }
    return returnList;
}
```
Edit:

Plus généralement, il est utile lorsque vous souhaitez retourner un type spécifique, ou que vous souhaitez lier les types de deux ou plusieurs paramètres d'une manière générale.

Par exemple, lorsque vous avez besoin de quelques universelle méthode pour les comparaisons:

public static <T extends Comparable> T max(T one, T two) {
    if (one.compareTo(two) > 0) {
        return one;
    } else {
        return two;
    }
}

Vous devez vous connecter pour publier un commentaire.