Discussion :

[kha_yassine]

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

[bhamp0]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

t.getClass().getName()

?

[kha_yassine]

Pour le T.getClass();

Ca donne :

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

[thelvin]

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

[bhamp0]

Moi pas comprendre quelque chose ?!

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
 
class A<T>{
	public String getNom(T t){
		return t.getClass().getName();
	}
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

java.lang.String
java.lang.Integer

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

[thelvin]

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.

[bhamp0]

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

[kha_yassine]

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)

[tchize_]

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)

[Rei Ichido]

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[merill]

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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_.

[tchize_]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public class A<T> {
    protected Class<T> getType(){
        ((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass();
    }
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public class C extends B {
 // ne marche plus
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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.

[romainw]

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
public class A<T> {
    protected Class<T> getType(){
        ((ParameterizedType)getClass().getGenericSuperclass()).getActualTypeArguments()[0].getClass();
    }
 
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
public class C extends B {
 // ne marche plus
}

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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 :

Sélectionner tout - Visualiser dans une fenêtre à part

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

[kha_yassine]

Oui ca marche bien

Merci beaucoup