Quando è utile una chiamata al metodo parametrizzata?

Question

metodo A Java chiamata può essere parametrizzata come nel codice seguente:

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

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

ho scoperto questo è possibile dalla finestra di impostazioni di Eclipse Java Formatter e mi chiedevo se ci sono dei casi in cui ciò è utile o necessario.

---

EDIT

Sulla base di risposta eccellente di Arne mi si avvicinò con la seguente conclusione:

Oltre a migliorare la sicurezza di tipo come esempio di Arne illustra una chiamata di metodo con parametri permette di specificare il tipo di base comune degli argomenti dei metodi che dovrebbero essere il tipo degli elementi del contenitore. Questo tipo viene normalmente inferito automaticamente dal compilatore al tipo di base comune più specifico. Parametrizzando la chiamata al metodo, questo comportamento può essere sovrascritto. Potrebbe essere necessaria una chiamata al metodo parametrizzata se sono presenti più tipi comuni inferiti dal compilatore.

Il seguente esempio dimostra che il comportamento:

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); 
    } 
} 

Questo comportamento è definito nei paragrafi linguaggio Java Specification Terza edizione 8.4.4 e 15.12.2.7 ma non facilmente comprensibile.

Answer 1

non ho mai usato questo, in pratica, ma si può immaginare di utilizzare questo tipo per la sicurezza.Si consideri il seguente metodo:

<T> void method(T... items) { 
    List<T> list = new ArrayList<T>(); 
    for (T item : items) 
     list.add(item); 
    System.out.println(list); 
} 

si può chiamare in questo modo:

o.<Object>method("Blah", new Long(0)); 
o.<Number>method(new Integer(100), new Long(0)); 

Ma questo genererà un errore di compilazione:

o.<Number>method("String", new Long(0)); 

in modo da avere un metodo generico che è typesafe e può essere utilizzato per ogni oggetto, non limitato a un'interfaccia o a una classe paricolare.

Answer 2

È probabilmente più utile quando si acquisisce una raccolta di un certo tipo e si restituisce un sottoinsieme di tale raccolta.

<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:

Più in generale, è utile ogni volta che si desidera restituire un tipo specifico, o se si vuole collegare i tipi di due o più parametri in modo generale.

Answer 3

Le chiamate con metodo parametrico sono utili quando si desidera consentire tipi diversi senza eseguire il cast. Ad esempio, la classe helper Collections fa ampio uso di chiamate di metodo con parametri. Quando si vuole fare una nuova collezione generico utilizzando uno dei loro metodi di supporto, alcuni esempi:

List<String> anEmptyStringList = Collections.<String>emptyList(); 
Set<Integer> unmodifiableCopy = Collections.<Integer>unmodifiableSet(originalSet); 

Così, quando si vuole essere in grado di utilizzare il tipo generico altrove, si vuole utilizzare tali chiamate di metodo. Impediscono gli avvertimenti del compilatore quando si usano i generici.

Answer 4

Ad esempio, quando avete bisogno di qualche metodo universale per il confronto:

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