Instanciation de générique

Version imprimable

22/04/2008, 10h51
Mobius

Instanciation de générique
Bonjour,

j'aimerai instancier un type générique un peu de cette facon (sauf que la ca ne marche pas) :
Code:

1 2 3 4 5 class MaClasse<AImpl extends A> { public void function test() { AImpl a = AImpl.class.newInstance(); } }
Je n'arrive pas a trouver d'exemple ou l'on peut faire ca (d'ailleur je ne sais même pas si c'est possible).
Avez vous une idée ?

Merci d'avance pour vos réponses.
22/04/2008, 10h56
natha
Tu ne peux pas faire ça. Les génériques disparaissent à la compilation.

La solution serait de fournir au constructeur de ta classe, une référence de la classe AImpl à instancier.
Code:

1 2 3 public MaClasse(Class<AImpl> clazz) { //... }
Ainsi tu pourras faire newInstance() sur clazz.
22/04/2008, 11h30
Mobius

Dommage...

J'ai commencé a regardé si on pouvait pas faire ca par introspection (j'ai vu ce genre de méthode "TypeVariable.getGenericDeclaration() " qui me laisse un peu d'espoir) mais je n'ai maleureusement pas énnormément de temps pour approfondir pour le moment :(

Si quelqu'un a une autre idée...

En tout cas merci natha, je vais faire comme tu as dis pour le moment (quitte a changer par la suite)

Edit: je passe le post en résolu car j'ai un moyen de contournement mais j'aimerai vraiment faire autrement. (donc toutes les idées sont encore les bienvenues)
22/04/2008, 12h42
Tommy31
Pas possible, même par introspection.

Le "TypeVariable.getGenericDeclaration() " que tu as vu, te permet de récupérer le type de la généricité tel que déclaré comme là:
Code:

1 2 3 4 5 6 public class TestType { List<String> aList; } System.out.println( TestType .class.getField("aList").getGenericType() );
Ca te retourne String.
22/04/2008, 13h03
adiGuba
Salut,

Citation:

Envoyé par Tommy31

Le "TypeVariable.getGenericDeclaration() " que tu as vu, te permet de récupérer le type de la généricité tel que déclaré comme là:

+1

En fait il faut comprendre que via la reflection on n'a accès qu'aux informations contenu dans le code de la classe. Par exemple si on a ceci :
Code:

1 2 3 public class MaClasse<T extends Number> { private List<T> list; }
On peut retrouver le T et savoir qu'il hérite de Number, mais on ne pourra pas déterminer si une instance en particulier utilise des Double ou des Integer...

a++
22/04/2008, 14h28
millie

Pour information, pourquoi souhaites-tu utiliser cela ? (je n'en ai jamais eu l'utilité comme ça)

Je vais essayer de l'expliquer par l'exemple en simplifiant pas mal.
Il s'agit de la lecture de différent type de référentiel.
Ma classe générique s'occupe des traitement comment de tous mes référentiels et ensuite elle est étendu autant de fois que nécessaire (en fonction des différrent référentiels lire
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 public abstract class ClasseGenerique<RefImpl extends Ref> { /** Cette méthode créer un objet de type RefImpl et le peuple avant de le retourner */ public RefImpl getReferentiel() { // Creation du référentiel et Traitement commun lors de la lecture du référentiel ... // Appel des traitement spécifique au référentiel traitementSpecifique(); } /** Traitement spécifique a ce type de référentiel */ public abstract void traitementSpecifique(); } public ClasseSpecifique extends ClasseGenerique<MonImplementationDuReferentiel> { public void traitementSpecifique() { // Traitement spécifique lors de la lecture du référentiel ... } }
Dans l'idée, il s'agit plus ou moins du pattern factory mais un peu adapté a mes besoins (ca en fera certainement bondir plus d'un mais c'est pas évident de se faire comprendre)

Il y a la méthode là, mais bon (ça permet au moins de gérer plus finement l'instanciation dans les classes filles) :mouarf:

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
public abstract class ClasseGenerique<RefImpl extends Ref> {
  protected abstract RefImpl getInstance();
 
  public RefImpl getReferentiel() {
    RefImpl imp =  getInstance();
    ...
    // Appel des traitement spécifique au référentiel
    traitementSpecifique();
  }
  /** Traitement spécifique a ce type de référentiel */
  public abstract void traitementSpecifique();
}
 
public ClasseSpecifique extends ClasseGenerique<MonImplementationDuReferentiel> {
  protected MonImplementationDuReferentiel getInstance() {
     return new MonImplementationDuReferentiel ();
  }
 
  public void traitementSpecifique() {
    // Traitement spécifique lors de la lecture du référentiel
    ...
  }
}

22/04/2008, 17h38
Mobius

C'est effectivement une autre facon de faire (qui faut l'avouer, a ses avantages).
Ceci dit, dommage qu'on ne puisse pas faire directement comme je pensais le faire au début, ca simplifirait ce genre de code...

Edit : je viens de me rendre compte que je ne suis pas le seul a avoir ce genre de problèmatique... (http://wiki.apache.org/tapestry/Tape...ectWithObjects) Quand on voit l'implémentation de leur première classe, on retrouve la première solution ;) )

Salut,

La solution a été donné par natha :

Citation:

Envoyé par natha

La solution serait de fournir au constructeur de ta classe, une référence de la classe AImpl à instancier.

Code:

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
abstract class ClasseGenerique<R extends Ref> {
 
	/** Type generics associé à la classe */
	private final Class<R> rType;
 
	/** Constructeur */
	public ClasseGenerique(Class<R> type) {
		if (type==null) {
			throw new NullPointerException("type is null");
		}
		this.rType = type;
	}
 
	/**
         * Méthode de création d'une instance
         * (le type R doit posséder un constructeur vide)
         * @return Une nouvelle instance de R
         * @throws RuntimeException en cas d'erreur lors de l'instanciation
         */
	public R newInstance() {
		try {
			return this.rType.newInstance();
		} catch (RuntimeException e) {
			// On remonte la runtimeexception tel quel
			throw e;
		} catch (Exception e) {
			// On englobe l'exception dans une Runtime
			throw new RuntimeException(e);
		}
	}
}

:arrow: Seul bémol il faut passer le type en paramètre lors de la création...

a++