Bonjour,

J'aimerais simplement avoir une précision sur l'implémentation du pattern factory.
Il y a quelque chose que je ne comprends pas alors je vais prendre un exemple :
J'ai une fabrique de controleurs (ControleurFactory) avec différentes méthodes de crétation pour mes divers controleurs (ControleurA, ControleurB...). Or dans de nombreux bouquins on explique que pour éviter le couplage, il ne faut pas que les méthodes de fabrication renvoient un objet du type concret mais un objet abstrait, une interface, qui serait commune à tous les controleurs dans mon exemple.
Pour illustrer :
Ce que je fais :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
public class ControleurFactory
{
     public ControleurA CreerControleurA() {...}
     public ControleurB CreerControleurB() {...}
}
Ce qu'il faudrait faire (d'après les bouquins) :
Code : Sélectionner tout - Visualiser dans une fenêtre à part
1
2
3
4
5
6
7
public class ControleurFactory
{
     public IControleur CreerControleurA() {...}
     public IControleur CreerControleurB() {...}
}
/* Avec IControleur, interface commune aux controleurs */
Dans la deuxième solution le code client manipule une interface et est donc "libéré" d'une implémentation concrète. Mais c'est là que je ne comprends plus : Le client il a bien besoin de manipuler une implémentation concrète, sinon comment pourrait-il accéder aux méthodes de mes différents controleurs ? il n'y a pas du tout la même chose dans controleurA et dans controleurB, donc comment manipuler cette interface si ce n'est en la recastant dans un type concret côté client pour utiliser les méthodes du controleur en question (ce qui n'a du coup plus aucun intérêt).
Donc dans une solution comme dans l'autre le code client est toujours couplé à une implémentation concrète.

Quelqu'un à compris qq chose et peut éventuellement me fournir des éléments de réponse ?

Merci