Dans la méthode générique <T> doSth (Liste <T> l), vérifiez si T implémente Comparable?

Question

Le titre dit tout: si j'ai une méthode java qui est générique dans T, puis-je trouver quelque chose à propos de T? En particulier, puis-je vérifier si T implémente une certaine interface ou étend une certaine classe?

Je voudrais faire quelque chose comme

public <T> List<T> doSth(List<T> l) { 

    if(T extends Comparable) { 
    // do one thing 
    } else { 
    // do another 
    } 

    return l; 
} 

Tous les conseils?

Merci beaucoup,

Johannes

Answer 1

Non - en raison de type erasure. Au moment de l'exécution, vous ne connaissez pas le type de T du tout.

Une option serait de spécifier le type comme un autre paramètre:

public <T> List<T> doSth(List<T> l, Class<T> clazz) { 
    if (Comparable.class.isAssignableFrom(clazz)) { 
     ... 
    } 
} 

Answer 2

oui, vous pouvez:

public <T> List<T> doSth(List<T> l) { 
    //You could also check every element, if there is a chance only some will be comparable 
    if (l.size() >0 && l.get(0) instanceof Comparable) { 
    // do one thing 
    } else { 
    // do another 
    } 

    return l; 
} 

Notez que vous vérifiez quel type les éléments dans "l" sont, PAS T - c'est la clé. Edit: Changement du code pour gérer le fait qu'il s'agissait d'une liste - j'avais manqué cela dans ma lecture originale.

Answer 3

Il n'est pas clair si vous souhaitez effectuer la vérification à la compilation ou à l'exécution. Si vous voulez simplement vous assurer que le paramètre list transmis à la méthode contient certains types d'objets, redéfinissez T de manière appropriée.

Par exemple, pour faire en sorte que le compilateur permettra seulement List<Comparable> à passer à cette méthode, redéfinissez T comme:

public <T extends Comparable<? super T>> List<T> doSth(List<T> l) { 
    // Method body omitted 
} 

Vous pouvez alors utiliser la méthode-surcharge (au lieu d'une instruction if-else), pour s'assurer que le code correct est appelé pour toute valeur de T. Autrement dit, remplacer:

public <T> List<T> doSth(List<T> l) { 

    if(T extends Comparable) { 
     // do one thing 
    } else { 
     // do another 
    } 

    return null 
} 

avec ces:

public <T extends Comparable<? super T>> List<T> doSth(List<T> l) { 
    // do one thing 
    return null; 
} 

public <T> List<T> doSth(List<T> l, Class<T> clazz) { 
    // do another 
    return null; 
} 

Cependant, vous devez vous rappeler choisir la méthode surchargée pour appeler et vérification de type générique est la compilation que! Par exemple, le code suivant:

List<? extends Serializable> alist = new ArrayList<Integer>(); 
doSth(alist); 

se fait appeler la deuxième méthode doSth, car le paramètre de type de compilation (? extends Serializable) ne met pas en œuvre Comparable, même si le paramètre de type d'exécution (Integer) fait.

Answer 4

Vous pouvez faire un

public <T extends Comparable<T>> List<T> doSth(List<T> l) 

qui vous permettra d'utiliser l'interface Comparable sur les articles dans 'l'

Answer 5

bien pour vérifier le temps de compilation Don a déjà donné une réponse. Pour l'exécution, il n'est possible que si vous passez également un objet explicite représentant T, par exemple:
static <T> List<T> doSth(List<T> l, Class<T> tClass) ayant un objet tClass représentant la vraie classe de T, vous pouvez vérifier s'il a implémenté une réflexion via la comparaison. Mais la vérification à la compilation est beaucoup, beaucoup mieux de mon point de vue.

Answer 6

Vous devriez déjà savoir à (même avant! :) la compilation si T s'étend Comparable ou non, alors pourquoi ne pas faire deux méthodes?

public <T extends Comparable<T>> List<T> doSthComp(List<T> l) { 
    // do one thing 
    return l; 
} 

public <T> List<T> doSth(List<T> l) { 
    // do another 
    return l; 
}