Probleme avec fonction generique

**sethlegoauld** · 14/02/2011, 19h33

Bonjour,
J'ai une classe AnnotationSet, qui herite de HashSet et qui a pour fonction d'etre au courant du type parametre. Par example, new AnnotationSet<String>().printGenericType() affiche String.

J'ai plusieurs types d'annotations, que j'ai regroupe dans une map(HashMap<Class<?>, AnnotationSet> annotations). Pour ajouter
de type String, j'ai implemente la fonction void addAnnotation(String annotation), qui fonctionne parfaitement (pour l'exemple, elle affiche le type de l'annotation). Mais comme les annotations sont generiques, la fonction pour en ajouter se doit de l'etre egalement, d'ou <T> void addAnnotation(T annotation). Et la, c'est le drame: divorse entre mon AnnotationSet<T> et sont type parametre <T> qui ne se reconnaissent plus

Y-a-t-il une solution a ce pb? Merci

PS: c'est quand meme un peu le bordel les generiques en Java...

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
 
public static void main(String[] args) {	
	HashMap<Class<?>, AnnotationSet>	annotations;
	// [...] some random code
	addAnnotation(new String("stuff"));		// Works fine: displays String
	addAnnotation(new Integer(1));			// NOT WORKING: displays UndeterminedType
}
 
/**
 * Adds a generic annotation
 * @Deprecated not working
 */
public <T> void addAnnotation(T annotation) {
	if (!annotations.containsKey(annotation.getClass()))
		annotations.put(annotation.getClass(), new AnnotationSet<T>(this) {}); // Notice the trivial anonymous class
	annotations.get(annotation.getClass()).add(annotation);
	annotations.get(go.getClass()).printGenericType();
}
/**
 * Add an annotation of type String
 */
public void addAnnotation(String annotation) {
	if (!annotations.containsKey(annotation.getClass()))
		annotations.put(annotation.getClass(), new AnnotationSet<String>(this) {}); // Notice the trivial anonymous class
	annotations.get(annotation.getClass()).add(annotation);
	annotations.get(go.getClass()).printGenericType();
}
 
public class AnnotationSet<T> extends HashSet<T> {
	/** To keep track of the parameterized type */
	private Class<?>				genericType;
	/** Object being annotated */
	private Object		parent		= null;
 
	/**
         * Class constructor.    *
         * @param parent Object being annotated
         */
	public AnnotationSet(WarehouseObject parent) {
		super();
		this.parent = parent;
 
		// From http://www.artima.com/weblogs/viewpost.jsp?thread=208860
		// this.genericType now contains the Class T
		this.genericType = ReflectionUtils.getTypeArguments(AnnotationSet.class, getClass()).get(0);
	}
 
	public void printGenericType() {
		try {
			System.out.println(genericType.getSimpleName());
		} catch (Exception e) {
			System.out.println("UndeterminedType");
		}
	}
} // eo AnnotationSet

**Jacobian** · 14/02/2011, 20h01

- déjas lorsque tu fais :

Code :

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

1
2
 
addAnnotation(new Integer(1));

c'est normale que vous auriez une erreur de type :
type String attendue au lieu de Integer

- aussi je comprend pas comment tu fait appel a une methode static dans une autre qui n'est pas static

**sethlegoauld** · 14/02/2011, 21h09

Envoyé par Jacobian

- déjas lorsque tu fais :

Code :

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

1
2
 
addAnnotation(new Integer(1));

c'est normale que vous auriez une erreur de type :
type String attendue au lieu de Integer

- aussi je comprend pas comment tu fait appel a une methode static dans une autre qui n'est pas static

Pour garder le code dans mon topic concis, je ne montre que des fragments de code qui sont pertinents. L'assemblage n'est pas des plus heureux, mais n'existe pas reellement. Dans cette lignee, selon les executions, l'une des variantes de addAnnotation() est commentee.

Ceci etant, addAnnotation(new Integer(1)) fait bien appel a <T> void addAnnotation(T annotation), avec T=Integer, le bug n'est pas a ce niveau.

**verbose** · 15/02/2011, 00h25

Il y a pas mal de choses qui ne collent pas dans ton code, et en particulier, tu as un problème d'architecture. Mais concernant juste les Générics, le type générique T déclaré pour la classe AnnotationSet et le type générique T déclaré pour la méthode addAnnotation() ne sont pas le même type, bien qu'ils portent la même lettre. C'est comme lorsqu'on déclare une variable, elle a une portée limitée, et deux variables peuvent avoir le même nom si elles ne sont pas dans la même portée (méthode ou classe).

**sethlegoauld** · 15/02/2011, 02h23

Envoyé par verbose

Il y a pas mal de choses qui ne collent pas dans ton code, et en particulier, tu as un problème d'architecture.

Tu pourrais détailler stp?

Envoyé par verbose

Mais concernant juste les Générics, le type générique T déclaré pour la classe AnnotationSet et le type générique T déclaré pour la méthode addAnnotation() ne sont pas le même type, bien qu'ils portent la même lettre. C'est comme lorsqu'on déclare une variable, elle a une portée limitée, et deux variables peuvent avoir le même nom si elles ne sont pas dans la même portée (méthode ou classe).

Cela tombe sous le sens... mais comment faire alors pour avoir une fonction addAnnotation() générique?

**khoufouq** · 15/02/2011, 08h28

Merci nous joindre les quelques classes coeur de ton problème pour qu'on puisse t'aider...

**thelvin** · 15/02/2011, 10h03

La méthode décrite en http://www.artima.com/weblogs/viewpo...?thread=208860 ne peut pas marcher.
L'exemple d'utilisation est un TypeAwareArrayList<String>, pas un TypeAwareArrayList<T>. Là est toute la différence.

Oublie cette méthode, elle ne va pas t'avancer. Vire ces conneries de new AnnotationSet<T>(this){} et de ReflectionUtils.getTypeArguments().

À la place, passe toi-même simplement l'objet Class qui sert de paramètre :

Code :

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

1
2
3
4
5
public AnnotationSet(WarehouseObject parent, Class<T> type) {
  super();
  this.genericType = type;
  // constructeur
}

Pour ça, modifie

Code :

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

public <T> void addAnnotation(T annotation)

en

Code :

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

public <T> void addAnnotation(T annotation, Class<T> type)

Ou alors appelle juste annotation.getClass(), mais cela renverra un Class<? extends T>, pas un Class<T>, donc il faut que le constructeur de AnnotationSet accepte un Class<? extends T>... Ce qui est mal. Donc va plutôt vers ma première idée.

Envoyé par sethlegoauld

PS: c'est quand meme un peu le bordel les generiques en Java...

Hélas. Conséquence malheureuse de l'avoir ajouté à de l'existant au lieu de l'avoir eu dès le départ.
Mais bon, tu cherches les ennuis, aussi. Aller chercher un truc comme ReflectionUtils.getTypeArguments(), à aucun moment tu t'es dit que si tu étais censé faire ça, ça prendrait moins d'une ligne, non ?
L'alarme "bon, manifestement, je suis pas sur la bonne voie" aurait dû être assourdissante.

**sethlegoauld** · 17/02/2011, 22h48

Envoyé par thelvin

À la place, passe toi-même simplement l'objet Class qui sert de paramètre :

Code :

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

1
2
3
4
5
public AnnotationSet(WarehouseObject parent, Class<T> type) {
  super();
  this.genericType = type;
  // constructeur
}

Pour ça, modifie

Code :

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

public <T> void addAnnotation(T annotation)

en

Code :

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

public <T> void addAnnotation(T annotation, Class<T> type)

OKI merci. J'avais essaye ca aussi par le passe, mais je voulais essayer d'utiliser cette methode (ReflectionUtils.getTypeArguments()) car elle permet d'eviter de passer Class<T> en argument, ce qui n'est pas ideal non plus. Mais bon, quand le remede devient pire que le mal d'origine...

Merci en tout cas

**thelvin** · 18/02/2011, 10h24

Envoyé par sethlegoauld

je voulais essayer d'utiliser cette methode (ReflectionUtils.getTypeArguments()) car elle permet d'eviter de passer Class<T> en argument

Elle n'évite rien du tout, au contraire elle impose compile-time de définir le type concret de T.
En gros, ce à quoi elle est censée servir n'est pas ton cas. L'auteur avait une autre idée en tête. (Qui ne me semble pas spécialement bonne non plus.)

**adiGuba** · 18/02/2011, 10h45

Envoyé par thelvin

Elle n'évite rien du tout, au contraire elle impose compile-time de définir le type concret de T.

Plus précisément elle génère une classe fille anonyme (voir plus) pour chaque type paramétré :

Code :

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

new AnnotationSet<String>(this) {}); // Notice the trivial anonymous class

Bref cela multiplie le bytecode par la création de plusieurs classes anonymes inutilement...

Si tu as vraiment besoin du type précis, il est préférable de le passer via un Class<T> comme indiqué par thelvin.

Au fait, pourquoi as-tu besoin de connaitre précisément le type ?

a++

Probleme avec fonction generique

Langage Java

Discussions similaires

Partager

Partager