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 les modèles de stratégie?
Pour moi, les deux sont identiques sauf une classe d'usine supplémentaire (qui crée un objet de produit dans des modèles d'usine)
Un modèle d'usine est un modèle de création. Un modèle de stratégie est un modèle opérationnel. Autrement dit, un modèle d'usine est utilisé pour créer des objets 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, tandis qu'un modèle de stratégie effectue des actions particulières, par exemple, Déplacer; en utilisant des stratégies Courir, Marcher ou Lope.
En fait, les deux peuvent être utilisés ensemble. Par exemple, vous pouvez avoir une fabrique qui crée vos objets 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 base de données différente, elle en utiliserait une autre.
Le modèle de stratégie vous permet de modifier polymorphiquement le comportement d'une classe.
Le modèle d'usine vous permet d'encapsuler la création d'objets.
Gary fait un bon 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 ajouter à ce que tvanfosson a dit, beaucoup de modèles se ressemblent en ce qui concerne la mise en œuvre. Autrement dit, vous avez souvent créé une interface là où il n'y en avait peut-être pas auparavant dans votre code, puis créé un tas d'implémentations de cette interface. La différence réside dans leur objectif et la façon dont ils sont utilisés.
- Le motif d'usine (méthode).
Créez uniquement des instances concrètes. Différents arguments peuvent entraîner différents objets. Cela dépend de la logique, etc.
- Le modèle de stratégie.
Encapsulez l'algorithme (étapes) pour effectuer une action. Vous pouvez donc modifier la stratégie et utiliser un autre algorithme.
Bien que les deux semblent très similaires, le but est plutôt différent, un but est de créer l'autre est d'effectuer une action.
Alors. Si votre méthode d'usine est fixe, 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 ait besoin d'une création plus avancée ou dynamique. Vous pouvez ajouter à la méthode d'usine une stratégie et la modifier sans avoir à recompiler, la stratégie peut changer au moment de l'exécution.
Il faut tout d'abord faire une différence entre une simple usine et une usine abstraite. La première est une simple fabrique où vous n'avez qu'une seule classe qui agit comme une fabrique pour la création d'objets, tandis que dans la seconde, vous vous connectez à une interface de fabrique (qui définit les noms de méthode), puis appelez les différentes usines qui implémentent cette interface qui sont censé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'aspect et la convivialité de Windows) et la seconde LinuxButtonCreationFactory (crée des boutons avec l'apparence et la convivialité de Linux). Ces deux usines ont donc la même méthode de création avec différentes implémentations (algorithmes). Vous pouvez référencer cela dans le runtime en fonction de la méthode que vous tapez sur le bouton souhaité.
Par exemple, si vous voulez des boutons avec l'apparence de 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 pour faire de la création. Cependant, il en diffère sémantiquement car il est utilisé pour la CRÉATION D'OBJETS plutôt que pour des algorithmes opérationnels. Donc, fondamentalement, avec la fabrique abstraite, vous avez la création d'objets en utilisant différentes stratégies, ce qui le rend très similaire au modèle de stratégie. Cependant, la AbstractFactory est créative, tandis que le modèle de stratégie est opérationnel. Du point de vue de la mise en œuvre, ils se révèlent être les mêmes.
Factory (et FactoryMethod renvoyé par Factory) :
- Modèle de création
- Basé sur l'héritage
- Factory renvoie une méthode Factory (interface) qui à son tour retourne un objet concret
- Vous pouvez remplacer de nouveaux objets concrets pour l'interface et le client (l'appelant) ne doit pas être au courant de toutes les implémentations concrètes
- Le client accède toujours à l'interface uniquement et vous pouvez masquer les détails de création d'objet dans la méthode Factory
Jetez un oeil à ce article wikipedia et article javarevisited
Modèle de stratégie:
- C'est un modèle comportemental
- C'est basé sur la délégation
- Il change les tripes de l'objet en modifiant le comportement de la méthode
- Il est utilisé pour basculer entre les familles d'algorithmes
- Il modifie le comportement de l'objet au moment de l'exécution
Exemple:
Vous pouvez configurer la stratégie de remise pour un article particulier (billet AirFare ou article ShoppingCart). Dans cet exemple, vous offrirez une remise de 25% sur un article en juillet - décembre et aucune remise sur l'article pendant le mois de juin - juin.
Articles Similaires:
Exemple réel du modèle de stratégie
Design Patterns: Factory vs Factory method vs Abstract Factory
Le modèle de stratégie en termes simples est davantage une création de comportement lors de l'exécution lorsque vous n'êtes pas concerné par la classe d'implémentation. De l'autre, la fabrique d'exécution est la création au moment de l'exécution d'une instance de classe concrète et c'est à vous d'utiliser tout comportement (méthode) exposé par l'interface implémentée.
Pour prolonger ce qu'a dit Oscar et en référence à son code:
Le getCommand est la fabrique et les classes UnixCommand, WindowsCommand et OSXCommand sont des stratégies
Vous ne pouvez pas comprendre la différence simplement en regardant le code ou la catégorisation. Pour saisir correctement les modèles GoF, recherchez leurs intentions:
Stratégie: "Définissez une famille d'algorithmes, encapsulez chacun d'eux 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 objet, mais laissez les sous-classes décider de la classe à instancier. La méthode d'usine permet à une classe de reporter l'instanciation aux sous-classes."
Et voici une explication détaillée sur les intentions et les différences entre ces deux modèles: Différence entre les modèles de conception de méthode d'usine et de stratégie
La stratégie et l'usine ont des objectifs différents. En stratégie, vous avez défini l'approche, en utilisant ce modèle, vous pouvez échanger le comportement (algorithmes). En venant à Factory, il y a beaucoup de variations. Mais le modèle original de l'usine des états GO4 laisse la création de l'objet à la classe enfant. Ici, avec l'usine, vous remplacez l'instance complète et non le comportement qui vous intéresse. Par cela, vous remplacerez le système complet et non l'algorithme.
Je peux m'éloigner d'Oscar dans la mesure où son exemple d'implémentation Factory est plutôt étroitement couplé et très fermé, pas étonnant que votre choix soit le modèle de stratégie. 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 suppose que le critère le plus approprié pour choisir l'une ou l'autre est principalement les termes que vous utilisez pour nommer vos classes et méthodes, en tenant compte du fait que nous devrions tous avoir tendance à programmer sur des interfaces et non sur des classes et aussi se concentrer sur l'objectif: nous visons à déterminer quel code s'exécutera lors de l'exécution. Cela dit, nous pouvons atteindre l'objectif en utilisant l'un des deux modèles.
Le modèle d'usine est un modèle de création, qui est créé avec des propriétés (comportement) spécifiées. lors de l'exécution après la création, vous ne pouvez pas modifier ses propriétés (comportement). donc si vous avez besoin de propriétés (comportement) différentes, vous devez supprimer l'objet et créer un nouvel objet avec les propriétés (comportement) nécessaires. ce qui n'est pas gud. tandis qu'en cas de modèle de stratégie, u peut modifier les propriétés (comportement) au moment de l'exécution.