<?> vs <T>

Question

je suis tombé sur une fonction qui ressemble à ceci:

public void function(Class<?> clazz) {...} 

Quels sont les avantages/inconvénients de changer la méthode:

public <T> void function(Class<T> clazz) {...} 

modifier: quels sont les temps de compilation/exécution diff.

Answer 1

todd.run est totalement à droite, mais ce n'est que la moitié de la réponse. Il existe également des cas d'utilisation pour choisir <T> sur <?> (ou vice versa) qui s'appliquent lorsque vous n'ajoutez pas de paramètre de type à la classe qui contient la méthode. Par exemple, considérez la différence entre

public <E extends JLabel> boolean add(List<E> j) { 
    boolean t = true; 
    for (JLabel b : j) { 
     if (b instanceof JLabel) { 
      t = t && labels.add(b); 
     } 
    } 
    return t; 
} 

et

public boolean add(List<? extends JLabel> j) { 
    boolean t = true; 
    for (JLabel b : j) { 
     if (b instanceof JLabel) { 
      t = t && labels.add(b); 
     } 
    } 
    return t; 
} 

La première méthode fait pas compiler SAUF si vous ajoutez un paramètre de type approprié à la classe englobante, tandis que la seconde méthode compilerons indépendamment du fait que la classe englobante a un paramètre de type. Si vous n'utilisez pas <?>, alors vous êtes localement responsable de dire au compilateur comment acquérir le type qui sera rempli par la lettre utilisée à sa place. Vous rencontrez fréquemment ce problème - besoin d'utiliser? plutôt que T - lorsque vous essayez d'écrire des méthodes génériques qui utilisent ou nécessitent "étend" et "super". Un traitement meilleur mais plus élaboré de ce problème est à la page 18 de Gilad Bracha's Generics Tutorial (PDF). Voir aussi this stack overflow question dont la réponse éclaire ces problèmes.

Consultez ce lien de débordement de pile pour plus d'informations sur votre deuxième question: Java generics - type erasure - when and what happens. Bien que je ne connais pas la réponse à votre question sur la différence de temps de compilation entre <?> et <T>, je suis assez sûr que la réponse peut être trouvée à this FAQ que erickson mentionné dans ce post.

Answer 2

Fondamentalement, ils sont équivalents. Vous pouvez utiliser la première syntaxe où vous n'avez pas besoin de déclarer quoi que ce soit de type T.

MISE À JOUR: oh, et T peut être utilisé pour lier les types ensemble: si Class<T> est utilisé dans différentes parties de la fonction, il se référera à la même classe, mais pas Class<?>.

Answer 3

L'utilisation de "?" est identique à "any", alors que "T" signifie "un type spécifique". Donc, comparer ces interfaces:

public interface StrictClass<T> { 
public T doFunction(Class<T> class); 
} 

public interface EasyClass<T> { 
public > doFunction(Class<?> class); 
} 

Maintenant, nous pouvons créer des classes:

public class MyStrictClass implements StrictClass<String> { 
    public String doFunction(Class<String> stringClass) { 
    //do something here that returns String 
    } 
} 

public class MyEasyClass implements EasyClass<String> { 
    public String doFunction(Class<?> anyClass) { 
    //do something here that returns String 
    } 
} 

Hope that helps!

Answer 4

Une bonne ressource pourrait être ceci: http://sites.google.com/site/io/effective-java-reloaded La partie intéressante liée à votre question commence autour de la 5ème minute. Juste en dépendance de ce que les utilisateurs précédents ont dit.

espoir qui aide:]