Instantiation générique dans une classe paramétrée

Version imprimable

Bonjour à tous,

Alors voilà j'ai un petit problème de généricité... Je ne sais pas comment contourner le problème et j'aurai souhaité avoir un maximum d'avis sur le sujet.

Voilà un code d'exemple de ce que je cherche à faire :

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
32
33
34
35
36
37
public abstract class AToto {
 
	protected final String str;
	protected final int i;
 
	public AToto(String str, int i) {
		this.str = str;
		this.i = i;
	}
}
public class DefaultToto extends AToto {
 
	public DefaultToto (String str, int i) {
		super(str, i);
	}
}
public class AnotherTotoImpl extends AToto {
 
	public AnotherTotoImpl (String str, int i) {
		super(str, i);
	}
}
public class TotoManager<T extends AToto> {
 
	private final List<T> list;
 
	public TotoManager(String str, int i) {
		list = new ArrayList<T>();
		T toto = new T(str, i);
		list.add(toto);
	}
}
 
public static void main(String[] args) {
	TotoManager<DefautToto> defaultTotoManager = new TotoManager<DefaultToto>("Test", 0);
	TotoManager<DefautToto> anotherTotoImplManager = new TotoManager<AnotherTotoImpl>("AntoherTest", 42);
}

Et je bloque sur cette instruction dans la classe TotoManager :

Code:

T toto = new T(str, i);

Une idée ?

Merci d'avance à tous !

04/12/2013, 16h30
toutgrego

Je ne pense pas que tu puisses instancier T

Bonjour,

Il n'est pas possible d'instancier un générique car toutes les informations génériques ne sont pas visibles à l'exécution. Les génériques sont juste utilisés pour la compilation (vérifier que les bon type est passé au bon endroit).

C'est comme si à l'exécution ton code avait cette forme :

Code:

1
2
3
4
5
6
7
8
9
10
public class TotoManager {
 
	private final List list;
 
	public TotoManager(String str, int i) {
		list = new ArrayList();
		// T toto = new T(str, i); je retire cette ligne qui ne peut pas être transformée...
		list.add(toto);
	}
}

1ère solution :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
public class TotoManager1<T extends AToto> {
 
		private final List<T> list;
 
		public TotoManager1(T toto) {
			list = new ArrayList<T>();
			list.add(toto);
		}
	}
 
// utilisation 
TotoManager1<DefaultToto> defaultTotoManager1 = new TotoManager1<DefaultToto>(new DefaultToto("Test", 0));

2ème solution :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
public class TotoManager2<T extends AToto> {
 
		private final List<T> list;
 
		public TotoManager2(String str, int i, Class<T> typeOfToto) {
			list = new ArrayList<T>();
			Constructor<?> constructor = typeOfToto.getConstructors()[0];
			try {
				T toto = (T) constructor.newInstance(str, i);
				list.add(toto);
			} catch (Exception e) {
				e.printStackTrace();
			}
		}
	}
 
// Utilisation 
TotoManager2<DefaultToto> defaultTotoManager2 = new TotoManager2<DefaultToto>("Test", 0, DefaultToto.class);

Si possible je préfère de loin la première qui implique moins de génériques et est plus orientée objet.

Romain.

Dans certains cas la solution de la factory est plus pratique :

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
interface TotoFactory<T extends AToto> {
  T newToto(String str, int i);
}
 
public class TotoManager<T extends AToto> {
 
  private final List<T> list;
  private final TotoFactory<T> factory;
 
  public TotoManager(TotoFactory<T> factory, String str, int i) {
    list = new ArrayList<T>();
    this.factory = factory;
 
    T toto = factory.newToto(str, i);
    list.add(toto);
  }
}
 
public class DefaultToto extends AToto {
  public DefaultToto (String str, int i) {
    super(str, i);
  }
 
  public static TotoFactory<DefaultToto> factory() {
    return new TotoFactory<DefaultToto>() {
      DefaultToto newToto(String str, int i) {
        return new DefaultToto(str, i);
      }
    }
  }
}

Code:

1
2
3
public static void main(String[] args) {
  TotoManager<DefautToto> defaultTotoManager = new TotoManager<>(DefaultToto.factory(), "Test", 0);
}

Mais cela oblige à prévoir une factory avec chaque classe Toto, c'est assez contraignant.

04/12/2013, 20h47
adiGuba

Salut,

Citation:

Envoyé par thelvin

Dans certains cas la solution de la factory est plus pratique

+1 pour la factory, ce qui est à mon sens la solution la plus propre.

Car rien ne garantie que toutes les classes descendant de AToto auront obligatoirement un constructeur prenant deux paramètres (String,int)...

a++
05/12/2013, 00h02
rg77140

La solution avec la factory ne me semble pas plus propre que la première solution que j'ai présentée car elle couple toujours TotoManager avec les propriétés internes de Toto. Tu es obligé de passer tous les paramètres pour construire Toto en paramètre de TotoManager ( sans compter que l'interface de la factory implique que Toto est toujours construit à partir d'un int et d'un String : T newToto(String str, int i); ).

Construire Toto en dehors de TotoManager permet de ne pas lier TotoManager aux propriétés internes de Toto.

Romain.
05/12/2013, 00h40
tchize_

Exact, sauf que je pense que l'idée implicité était, vu la présence de a liste, que le manager crée les T à la demande ... Si effectivement il peux se contenter de stocker ce qu'on lui passe, c'est le plus propre.
07/12/2013, 09h15
Dark_TeToN

Merci à tous pour ces réponses !

Bon il s'avère qu'au final ma conception était mauvaise et en la revoyant je n'ai plus eu besoin de ça.

Ceci dit merci pour toutes vos réponses, cela m'a permis d'apprendre des choses.

Dans mon cas la solution de la factory aurait effectivement été la plus pratique (et un pattern très utilisé en entreprise il me semble).

En fait c'est surtout que je voulais avoir une méthode qui instancie bon type de Toto dans mon manager et me le revoie mais bon... Je n'en ai rien fait au final (enfin j'en ai fait quelque chose quand même puisque je me coucherais moins bête ce soir ! :langue2:)

Merci quand même à tous !