Quelle est la différence entre les modèles Factory et Strategy?

Quelqu’un peut-il expliquer la différence entre les modèles d’usine et de stratégie?

Pour moi, tous les deux ont la même apparence qu’une classe d’usine supplémentaire (qui crée un object de produit dans les modèles d’usine)

Un motif d’usine est un motif créatif. Un modèle de stratégie est un modèle opérationnel. En d’autres termes, un motif d’usine est utilisé pour créer des objects d’un type spécifique. Un modèle de stratégie est utilisé pour effectuer une opération (ou un ensemble d’opérations) d’une manière particulière. Dans l’exemple classique, une usine peut créer différents types d’animaux: Chien, Chat, Tigre, alors qu’un modèle de stratégie effectuerait des actions particulières, par exemple Déplacer; en utilisant les stratégies Run, Walk ou Lope.

En fait, les deux peuvent être utilisés ensemble. Par exemple, vous pouvez avoir une fabrique qui crée vos objects métier. Il peut utiliser différentes stratégies basées sur le support de persistance. Si vos données sont stockées localement en XML, elles utiliseraient une stratégie. Si les données étaient distantes dans une firebase database différente, il en utiliserait une autre.

Le modèle de stratégie vous permet de modifier de manière polymorphe le comportement d’une classe.

Le motif d’usine vous permet d’encapsuler la création d’object.

Gary fait un excellent point. Si vous utilisez le principe du codage des abstractions plutôt que des “concrétions”, alors beaucoup de motifs commencent à ressembler à des variations sur un thème.

Juste pour append à ce que tvanfosson a dit, beaucoup de modèles se ressemblent en ce qui concerne la mise en œuvre. C’est-à-dire que vous avez beaucoup créé une interface où il n’y en avait peut-être pas auparavant dans votre code, puis créé un ensemble d’implémentations de cette interface. La différence est dans leur objective et comment ils sont utilisés.

  • Le motif d’usine (méthode).

Créez des instances concrètes uniquement. Différents arguments peuvent entraîner des objects différents. Ça dépend de la logique etc.

  • Le modèle de stratégie

Encapsulez l’algorithme (étapes) pour effectuer une action. Vous pouvez donc changer de stratégie et utiliser un autre algorithme.

Bien que les deux semblent très similaires, le but est plutôt différent, l’un des buts étant de créer l’autre est d’effectuer une action.

Alors. Si votre méthode Factory est corrigée, vous pouvez l’avoir comme ceci:

public Command getCommand( int operatingSystem ) { switch( operatingSystem ) { case UNIX : case LINUX : return new UnixCommand(); case WINDOWS : return new WindowsCommand(); case OSX : return new OSXCommand(); } } 

Mais supposons que votre usine nécessite une création plus avancée ou dynamic. Vous pouvez append à la méthode d’usine une stratégie et la modifier sans avoir à recomstackr, la stratégie peut changer à l’exécution.

Avant toute chose, il faut faire la différence entre une usine simple et une usine abstraite. Le premier est une fabrique simple où vous ne disposez que d’une seule classe qui sert de fabrique pour la création d’objects, tandis que dans le second, vous vous connectez à une interface de fabrique (qui définit les noms de méthodes) puis appelez les différentes usines implémentant cette interface. sont supposés avoir différentes implémentations de la même méthode en fonction de certains critères. Par exemple, nous avons une interface ButtonCreationFactory, qui est implémentée par deux usines, la première WindowsButtonCreationFactory (crée des boutons avec l’apparence Windows) et la seconde LinuxButtonCreationFactory (crée des boutons avec l’apparence Linux). Ces deux usines ont donc la même méthode de création avec différentes implémentations (algorithmes). Vous pouvez faire référence à ceci dans l’exécution en fonction de la méthode que vous tapez le bouton que vous souhaitez.

Par exemple, si vous voulez des boutons avec une apparence Linux:

 ButtonCreationFactory myFactory = new LinuxButtonCreationFactory(); Button button1 = myFactory.createButton(...); 

ou si vous voulez des boutons Windows

 ButtonCreationFactory myFactory = new WindowsButtonCreationFactory(); Button button1 = myFactory.createButton(...); 

Exactement dans ce cas, il en résulte une sorte de modèle de stratégie, car il différencie les algorithmes de création. Cependant, il en diffère sémantiquement car il est utilisé pour la création d’objects plutôt que pour des algorithmes opérationnels. Donc, fondamentalement avec la fabrique abstraite, vous avez la création d’objects en utilisant différentes stratégies, ce qui la rend très similaire au modèle de stratégie. Cependant, le AbstractFactory est créatif, tandis que le modèle de stratégie est opérationnel. En ce qui concerne la mise en œuvre, ils se traduisent par la même chose.

Factory (et FactoryMethod retourné par Factory) :

  1. Motif de création
  2. Basé sur l’inheritance
  3. Factory retourne une méthode d’usine (interface) qui à son tour renvoie un object concret
  4. Vous pouvez remplacer les nouveaux objects concrets par l’interface et le client (appelant) ne doit pas connaître toutes les implémentations concrètes.
  5. Client toujours accéder à l’interface uniquement et vous pouvez masquer les détails de création d’object dans la méthode Factory

Jetez un coup d’œil à cet article de wikipedia et à cet article javarevisited

Modèle de stratégie:

  1. C’est un modèle comportemental
  2. C’est basé sur la délégation
  3. Il modifie les entrailles de l’object en modifiant le comportement de la méthode
  4. Il permet de passer d’une famille d’algorithmes à l’autre
  5. Il modifie le comportement de l’object au moment de l’exécution

Exemple:

Vous pouvez configurer une stratégie de remise pour un article particulier (billet AirFare ou article ShoppingCart). Dans cet exemple, vous offrirez un rabais de 25% sur un article en juillet-décembre et aucune remise sur l’article pendant le mois de juin – juin.

Articles Similaires:

Real World Exemple de modèle de stratégie

Modèles de conception: Méthode Factory vs Factory vs Abstract Factory

Pour prolonger ce que Oscar a dit et en référence à son code:

GetCommand est la fabrique et les classes UnixCommand, WindowsCommand et OSXCommand sont des stratégies

Le modèle de stratégie en termes simples est davantage une création de comportement à l’exécution lorsque vous n’êtes pas concerné par la classe d’implémentation. De l’autre côté, factory était la création d’une instance de classe concrète et c’est à vous d’utiliser n’importe quel comportement (méthode) exposé par l’interface implémentée.

Je peux digresser avec Oscar en ce sens que son exemple d’implémentation Factory est assez étroitement couplé et très fermé, pas étonnant que votre choix soit le pattern Strategy. Une implémentation Factory ne doit pas dépendre d’un nombre fixe de classes spécifiques en cours d’instanciation. Par exemple:

 public Command getCommand( int operatingSystem ) { return commandTable.get(operatingSystem); } ... public class WindowsCommand implements Command { ... static { CommandTable.getInstance().registerCommand(WIN_COMMAND_ID, new WindowsCommand()); } } 

Je pense que les critères les plus appropriés pour choisir l’une ou l’autre sont les termes que vous employez pour nommer vos classes et méthodes, en tenant compte du fait que nous devrions tous programmer les interfaces et non les classes et nous concentrer sur l’objective: quel code s’exécutera à l’exécution. Cela dit, nous pouvons atteindre cet objective en utilisant l’un des deux modèles.

La stratégie et l’usine sont des objectives différents. Dans la stratégie, l’approche est définie, en utilisant ce modèle, vous pouvez échanger le comportement (algorithmes). Venir à l’usine, il y a beaucoup de variations autour. Mais le modèle original de la fabrique d’états GO4 laisse la création d’object à la classe enfant. Ici, avec l’usine, vous remplacez l’instance complète et non le comportement qui vous intéresse. Vous remplacerez ainsi le système complet et non l’algorithme.

Le motif d’usine est un motif de création créé avec les propriétés spécifiées (comportement). tandis qu’à l’exécution, après la création, nous ne pouvons pas modifier ses propriétés (comportement). donc si vous avez besoin de propriétés différentes (comportement), vous devez supprimer l’object et créer un nouvel object avec les propriétés nécessaires (comportement). ce qui n’est pas gud. alors que dans le cas d’un modèle de stratégie, vous pouvez modifier les propriétés (comportement) au moment de l’exécution.

Vous ne pouvez pas comprendre la différence simplement en regardant le code ou la catégorisation. Pour saisir correctement les patrons GoF, recherchez leurs intentions:

Stratégie: “Définissez une famille d’algorithmes, encapsulez-les et rendez-les interchangeables. La stratégie permet à l’algorithme de varier indépendamment des clients qui l’utilisent.”

Méthode d’usine: “Définissez une interface pour créer un object, mais laissez les sous-classes décider quelle classe instancier. La méthode d’usine permet à une classe de reporter l’instanciation aux sous-classes.”

Et voici une explication détaillée des intentions et des différences entre ces deux modèles: Différence entre les modes de conception Factory Method et Strategy