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

Les trois types Factory font la même chose: ils sont un “constructeur intelligent”.

Disons que vous voulez pouvoir créer deux types de fruits: Apple et Orange.

Usine

Factory est “corrigé”, en ce sens que vous n’avez qu’une seule implémentation sans sous-classement. Dans ce cas, vous aurez une classe comme celle-ci:

class FruitFactory { public Apple makeApple() { // Code for creating an Apple here. } public Orange makeOrange() { // Code for creating an orange here. } } 

Cas d’utilisation: Construire un Apple ou un Orange est un peu trop complexe à gérer dans le constructeur.

Méthode d’usine

La méthode d’usine est généralement utilisée lorsque vous avez un traitement générique dans une classe, mais que vous souhaitez modifier le type de fruit que vous utilisez réellement. Alors:

 abstract class FruitPicker { protected abstract Fruit makeFruit(); public void pickFruit() { private final Fruit f = makeFruit(); // The fruit we will work on..  } } 

… alors vous pouvez réutiliser la fonctionnalité commune dans FruitPicker.pickFruit() en implémentant une méthode d’usine dans les sous-classes:

 class OrangePicker extends FruitPicker { @Override protected Fruit makeFruit() { return new Orange(); } } 

Usine abstraite

La fabrique abstraite est normalement utilisée pour des choses comme l’injection / stratégie de dépendance, lorsque vous voulez pouvoir créer une famille complète d’objects qui doivent être du même type et avoir des classes de base communes. Voici un exemple vaguement lié au fruit. Le cas d’utilisation est que nous voulons nous assurer que nous n’utilisons pas accidentellement un OrangePicker sur un Apple. Tant que nous aurons nos fruits et cueilleurs de la même usine, ils seront assortis.

 interface PlantFactory { Plant makePlant(); Picker makePicker(); } public class AppleFactory implements PlantFactory { Plant makePlant() { return new Apple(); } Picker makePicker() { return new ApplePicker(); } } public class OrangeFactory implements PlantFactory { Plant makePlant() { return new Orange(); } Picker makePicker() { return new OrangePicker(); } } 

Factory – Separate Factory class pour créer un object complexe.

Ex: classe FruitFactory pour créer un object de Fruit

 class FruitFactory{ public static Fruit getFruit(){...} } 

Méthode d’usine – Au lieu de toute classe séparée pour la fabrique, ajoutez simplement une méthode dans cette classe en tant que fabrique.

Ex:

 Calendar.getInstance() (Java's Calendar) 

Méthode d’usine abstraite – Factory of Factory

Ex: Disons que nous voulons construire une usine pour les pièces d’ordinateur. Il existe donc plusieurs types d’ordinateurs tels que Laptop, Desktop, Server.

Donc, pour chaque type de calcul, nous avons besoin d’une usine. Donc, nous créons une usine de haut niveau des usines comme ci-dessous

 ComputerTypeAbstractFactory.getComputerPartFactory(Ssortingng computerType) ---> This will return PartFactory which can be one of these ServerPartFactory, LaptopPartFactory, DesktopPartFactory. 

Maintenant, ces 3 mêmes sont à nouveau des usines. (Vous aurez affaire à PartFactory lui-même, mais sous le capot, il y aura une implémentation séparée basée sur ce que vous avez fourni dans la fabrique abstraite)

  Interface-> PartFactory. getComputerPart(Ssortingng s), Implementations -> ServerPartFactory, LaptopPartFactory, DesktopPartFactory. Usage: new ComputerTypeAbstractFactory().getFactory(“Laptop”).getComputerPart(“RAM”) 

EDIT: édité pour fournir des interfaces exactes pour Abstract Factory conformément aux objections dans les commentaires.

1. En quoi ces trois modèles sont-ils différents les uns des autres?

Factory: crée des objects sans exposer la logique d’instanciation au client.

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 Factory permet à une classe de différer l’instanciation aux sous-classes

Fabrique abstraite: fournit une interface pour créer des familles d’objects liés ou dépendants sans spécifier leurs classes concrètes.

Le modèle AbstractFactory utilise la composition pour déléguer la responsabilité de créer un object à une autre classe, tandis que le modèle de conception de la méthode Factory utilise l’inheritance et s’appuie sur une classe ou une sous-classe dérivée pour créer un object.

2. Quand utiliser lequel?

Factory: le client a juste besoin d’une classe et ne se soucie pas de l’implémentation concrète qu’il obtient.

Méthode d’usine: Le client ne sait pas quelles classes concrètes il devra créer à l’exécution, mais veut simplement obtenir une classe qui fera le travail.

AbstactFactory: lorsque votre système doit créer plusieurs familles de produits ou que vous souhaitez fournir une bibliothèque de produits sans exposer les détails de l’implémentation.

Les classes Factory abstraites sont souvent implémentées avec la méthode Factory. Les méthodes d’usine sont généralement appelées dans les méthodes de modèle.

3. Et aussi si possible, des exemples java liés à ces modèles?

Factory et FactoryMethod

Intention:

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 différer l’instanciation aux sous-classes.

Diagramme UML :

Produit: définit une interface des objects créés par la méthode Factory.

ConcreteProduct: Implémente l’interface produit

Créateur: déclare la méthode Factory

ConcreateCreator: Implémente la méthode Factory pour retourner une instance d’un ConcreteProduct

Énoncé du problème: Créez une fabrique de jeux en utilisant les méthodes d’usine, qui définissent l’interface du jeu.

Extrait de code:

Motif d’usine Quand utiliser les méthodes d’usine?

Comparaison avec d’autres modèles créatifs:

1. Conception démarrée à l’aide de la méthode d’usine (moins compliquée, plus personnalisable, prolifération de sous-classes) et évolution vers la fabrique abstraite, le prototype ou le générateur (plus flexible, plus complexe) que le concepteur découvre

2. Les classes Factory abstraites sont souvent implémentées avec les méthodes Factory , mais elles peuvent aussi être implémentées avec Prototype

Références pour d’autres lectures: Modèles de conception de fabrication

Chaque modèle de conception prospère pour garantir que le code de travail écrit ne soit pas touché. Nous soaps tous qu’une fois que nous touchons au code de travail, il y a des défauts dans les stream de travail existants, et beaucoup plus de tests doivent être effectués pour nous assurer de ne rien casser.

Un motif de fabrique crée des objects en fonction de critères d’entrée, ce qui garantit que vous n’avez pas besoin d’écrire du code comme si cela créait cet object. Un bon exemple de ceci est un site Web de voyage. Un site Web de voyage ne peut fournir que des voyages (vol, train, bus) et / ou fournir des hôtels ou des forfaits d’attraction touristique. Désormais, lorsqu’un utilisateur sélectionne ensuite, le site Web doit décider des objects à créer. Devrait-il uniquement créer l’object de voyage ou d’hôtel?

Maintenant, si vous envisagez d’append un autre site Web à votre portefeuille et que vous pensez que le même kernel peut être utilisé, par exemple un site de covoiturage, qui recherche maintenant les taxis et effectue des paiements en ligne, vous pouvez utiliser une usine abstraite. De cette façon, vous pouvez simplement installer une autre usine de taxis et de covoiturage.

Les deux usines n’ont rien à voir les unes avec les autres, donc c’est un bon design pour les garder dans des usines différentes.

J’espère que c’est clair maintenant. Étudiez le site Web en gardant à l’esprit cet exemple, j’espère que cela vous aidera. Et j’espère vraiment avoir représenté les motifs correctement :).

 AbstractProductA, A1 and A2 both implementing the AbstractProductA AbstractProductB, B1 and B2 both implementing the AbstractProductB interface Factory { AbstractProductA getProductA(); //Factory Method - generate A1/A2 } 

En utilisant la méthode d’usine, l’utilisateur peut créer A1 ou A2 de AbstractProductA.

 interface AbstractFactory { AbstractProductA getProductA(); //Factory Method AbstractProductB getProductB(); //Factory Method } 

Mais Abstract Factory ayant plus d’une méthode d’usine (ex: 2 méthodes d’usine), en utilisant ces méthodes d’usine, il créera l’ensemble d’objects / objects associés. À l’aide de Abstract Factory, l’utilisateur peut créer des objects A1, B1 de AbstractProductA, AbstractProductB