Nom de la classe générique

Salut tout le monde,

Je me demande si je peux savoir le nom de la classe générique lors de l'exécution de mon programme,

Je m'explique :

Étant donné la classe A suivante :

class A<T>{
public String getNom(T t){
return nomDeLaClasseT(T);
}
}

et merci d'avance :)

Code:

---

t.getClass().getName()

---

?

Pour le T.getClass();

Ca donne :

Citation:

---

Cannot make a static reference to the non-static method getClass() from the type Object

---

On peut pas, non. Au Runtime, les génériques ça n'existe plus, donc cette information n'existe pas.

Il est possible, si nécessaire, de demander un objet Class<T> en paramètre du constructeur de ta classe, ce qui du coup permet de retenir la classe utilisée et de s'en servir. Mais l'intérêt, bon...

Moi pas comprendre quelque chose ?!

Code:

---

1 2 3 4 5 6

class A<T>{ public String getNom(T t){ return t.getClass().getName(); } }

---

Code:

---

1 2 3 4 5 6 7 8 9 10

public class Main { public static void main(String[] args) { A<String> a = new A<String>(); System.out.println(a.getNom("toto"));   A<Integer> b = new A<Integer>(); System.out.println(b.getNom(Integer.valueOf(1))); } }

---

Ca me donne :

Citation:

---

java.lang.String
java.lang.Integer

---

C'était pas ça l'idée de départ ?!

Moi je croyais qu'on n'avait pas sous la main une instance de T. On peut toujours faire getClass() sur une instance.

Toutefois, attention, t n'est pas forcément de classe T. Ça peut être une sous-classe.

Ah oui, en effet, si l'objectif est d'avoir T, ça ne me semble pas possible ...

Merci beaucoup pour vos réponses :)

Je vais voir si on ne peut pas travailler autrement (sans tenter de récupérer le nom de la classe T)

Si je peux apporter une précision. Il faut bien être conscient que la classe générique A est compilée par le compilateur comme si T est un Object.

Le generic sont traités par l'appelant, pas par l'appelé, contrairement au C++.

Ainsi, une méthode public void do(T t), aura pour signature do(Object) ;)
Donc toute tentative depuis la classe de savoir comment on a été typé à l'instanciation est vouée à l'échec, cette information est inexistante en dehors de l'appelant. Donc si l'appelé a besoin de connaitre le type concret, il faudra lui passer en paramètre de la méthode (via un paramètre Class<T> par exemple)

Dernière précision : si tu as effectivement implémenté la classe, alors le type peut être connu.

Typiquement, quand tu crées une classe utilitaire destinée à être implémentée N fois, et que tu ne veux pas ré-écrire dans chaque classe une méthode qui retourne le type implémenté, tu peux utiliser :

Code:

---

1 2	((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass().getName()

---

En faisant attention au nombre de types d'arguments déclarés, à ce que ça passe par une classe héritée ou une interface, etc.

Citation:

---

Envoyé par Rei Ichido

Code:

---

1 2	((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass().getName()

---

En faisant attention au nombre de types d'arguments déclarés, à ce que ça passe par une classe héritée ou une interface, etc.

---

Je n'aime pas trop cette fonctionnalité qui peut bugguer dès qu'une sous-classe ajoute ou change l'ordre des types.
Si l'on utilise cette méthode, il vaut mieux mettre la classe en final, histoire de s’éviter ces problèmes.
Ou alors utiliser une variable Class<T> comme l'a préconisé tchize_.

Ce code est de la bidouille qui va sauter à la première utilisation de l'héritage. Exemple

Code:

---

1 2 3 4 5 6 7

public class A<T> { protected Class<T> getType(){ ((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass(); }   }

---

Code:

---

1 2 3

public class B extends A<String> { //marchera }

---

Code:

---

1 2 3

public class C extends B { // ne marche plus }

---

Code:

---

1 2 3

public class D<U,V> extends A<U> { // ne marchera pas }

---

Code:

---

private A<Integer> a = new A<Integer>(); // ne marchera pas

---

A part pour les deux derniers points, on peux améliorer le code de getType pour qu'il soit un peu plus souple et determine correctement le type concerné. Mais dans les deux derniers cas, impossible.

Citation:

---

Envoyé par tchize_

Ce code est de la bidouille qui va sauter à la première utilisation de l'héritage. Exemple

Code:

---

1 2 3 4 5 6 7

public class A<T> { protected Class<T> getType(){ ((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass(); }   }

---

Code:

---

1 2 3

public class B extends A<String> { //marchera }

---

Code:

---

1 2 3

public class C extends B { // ne marche plus }

---

Code:

---

1 2 3

public class D<U,V> extends A<U> { // ne marchera pas }

---

Code:

---

private A<Integer> a = new A<Integer>(); // ne marchera pas

---

A part pour les deux derniers points, on peux améliorer le code de getType pour qu'il soit un peu plus souple et determine correctement le type concerné. Mais dans les deux derniers cas, impossible.

---

Effectivement en cas d'héritage ça peut être instable. En fait pour que ça marche il faut que ta classe hérite elle même d'une super classe qui sera paramétrée par ton type. Dans ce cas tu peux faire un truc du genre :

Code:

---

1 2 3 4 5 6 7 8 9 10 11 12

public static Type[] getTypeArguments(Class<?> clazz) { if (null == clazz) { return null; } Type type = clazz.getGenericSuperclass(); while ((null != type) && (!(type instanceof ParameterizedType))) { type = ((Class) type).getGenericSuperclass(); } return ((null != type) ? ((ParameterizedType) type) .getActualTypeArguments() : null); }

---

Oui ca marche bien

Merci beaucoup :)