Mode Méthode d'usine
La motivation à créer un objet nécessite souvent un processus complexe, il ne convient donc pas à l'inclusion dans une usine composite. Lorsqu'il y a de nouveaux produits, l'usine composite doit être modifiée, ce qui n'est pas propice à l'expansion.
De plus, la création de certains objets peut nécessiter des informations accessibles par l'usine composite. Par conséquent, définissez une interface d'usine et déterminez quel produit est instancié en implémentant cette interface. Il s'agit du modèle de méthode d'usine, qui retarde l'instanciation de la classe à la sous-classe.
But
1. Définissez une interface et laissez la sous-classe décider quel produit instancier.
2. Créez des objets via une interface commune.
accomplir
1. L'interface du produit et les produits spécifiques sont faciles à comprendre.
2. La classe d'usine fournit une méthode d'usine qui renvoie un objet produit. Mais cette méthode d'usine est abstraite.
3. Mettre en œuvre des méthodes d'usine dans des usines spécifiques et terminer la création de produits spécifiques.
// Bouton de classe de classes de bouton {/ * ... * /} classe WinButton étend le bouton {/ * ... * /} classe MacButton étend le bouton {/ * ... * /} // leur interface de classes d'usine ButtonFactory {Button Abstract CreateButton (); } classe WinButtonFactory implémente ButtonFactory {Button CreateButton () {return new WinButton (); }} classe MacButtonFactory implémente ButtonFactory {Button CreateButton () {return new MacButton (); }} Scénarios applicables
1. Lorsqu'il y a plus de code en double lors de la création d'un objet, vous pouvez envisager d'utiliser le modèle de méthode d'usine pour exécuter ces pièces en double.
2. La création d'un objet nécessite l'accès à certaines informations, qui ne doivent pas être incluses dans la classe d'usine. Ensuite, les sous-classes peuvent implémenter la création de l'objet.
3. Lorsque vous devez gérer de manière centralisée la création d'objets pour maintenir la cohérence du programme.
Modèle d'usine abstrait
La définition des modèles d'usine abstraits fournit un moyen de résumer un ensemble d'usines distinctes avec le même thème. En usage normal, le programme client doit créer une implémentation concrète de l'usine abstraite, puis utiliser l'usine abstraite comme interface pour créer un objet concret pour ce sujet. Le programme client n'a pas besoin de savoir (ou de prendre soin) qu'il obtient le type spécifique d'objets de ces méthodes d'usine internes, car le programme client utilise uniquement l'interface commune de ces objets. Le modèle d'usine abstrait sépare les détails d'implémentation d'un ensemble d'objets de leur utilisation générale.
Une "usine" est l'endroit où les produits (objets) sont créés, et son objectif est de séparer la création de produits de leur utilisation. Le but du modèle d'usine abstrait est de séparer les interfaces de plusieurs produits abstraits de la mise en œuvre spécifique de différents produits à thème. De cette façon, lors de l'ajout d'une nouvelle usine spécifique, vous ne pouvez pas avoir besoin de modifier le code client qui fait référence à l'usine abstraite.
L'utilisation du modèle d'usine abstraite vous permet de modifier l'usine spécifique sans modifier le code client à l'aide de l'usine, même au moment de l'exécution. Cependant, l'utilisation de ce modèle ou des modèles de conception similaires peut apporter une complexité inutile et un travail supplémentaire à l'écriture de code. Une utilisation appropriée des modèles de conception peut compenser un tel "travail supplémentaire".
accomplir
1. AbstractFactory - définit la méthode d'interface pour créer des produits abstraits.
2. ConcreteFactory - Implémentez la méthode pour créer des produits spécifiques.
3. AbstractProduct - Une interface qui déclare différents types de produits.
4. Produit - Définissez les produits spécifiques correspondant à ConcreteFactory et implémentez l'interface AbstractProduct.
5. Client - Utilisez des classes AbstractFactory et AbstractProduct.
Résumé classe AbstractProducta {public abstract void operationa1 (); abstrait void operationa2 (); } class Producta1 étend AbstractProducta {producta1 (String arg) {System.out.println ("Hello" + Arg); } // Implémentez le code ici public void operationa1 () {}; public void operationa2 () {}; } class Producta2 étend AbstractProducta {producta2 (String arg) {System.out.println ("Hello" + Arg); } // Implémentez le code ici public void operationa1 () {}; public void operationa2 () {}; } classe abstraite abstractProductB {// public abstract void operationb1 (); // public abstract void operationb2 (); } classe ProductB1 étend AbstractProductB {productB1 (String arg) {System.out.println ("Hello" + Arg); } // Implémentez le code ici} classe ProductB2 étend AbstractProductB {ProductB2 (String Arg) {System.out.println ("Hello" + Arg); } // Implémentez le code ici} classe abstraite AbstractFactory {Abstract AbstractProducta CreateProducta (); Résumé AbstractProductB CreateProductB (); } classe ConcreteFactory1 étend AbstractFactory {AbstractProducta CreateProducta () {return new Producta1 ("producta1"); } AbstractProductB CreateProductB () {return new ProductB1 ("ProductB1"); }} classe ConcreteFactory2 étend AbstractFactory {AbstractProducta CreateProducta () {return new Producta2 ("producta2"); } AbstractProductB CreateProductB () {return new ProductB2 ("ProductB2"); }} // Créateur d'usine - une manière indirecte d'instanciation de la classe d'usines FactoryMaker {private static abstractFactory pf = null; STATIC AbstractFactory GetFactory (String Choice) {if (choix.equals ("a")) {pf = new ConcreteFactory1 (); } else if (choix.equals ("b")) {pf = new ConcreteFactory2 (); } return pf; }} // Client public class Client {public static void main (String args []) {abstractFactory pf = factorymaker.getFactory ("a"); AbstractProducta Product = pf.CreateProducta (); // Plus d'appels de fonction sur le produit}}La classe FactoryMaker utilise le mode d'usine simple, tandis que l'implémentation d'usines spécifiques utilise le mode de méthode d'usine.
Scénarios applicables
1. Un système est indépendant de la création, de la composition et de la représentation de ses produits.
2. Lorsqu'un système est configuré par l'une des multiples familles de produits.
3. Il est nécessaire de souligner la conception d'une série d'objets de produit connexes à usage conjoint.
4. Fournissez une bibliothèque de produits et ne souhaitent afficher leurs interfaces au lieu des implémentations.
avantage
1. Les produits spécifiques sont séparés du code client
2. Une série qui peut facilement changer
3. Créez une série de familles de produits ensemble
défaut
1. Il est difficile d'élargir les nouveaux produits dans la famille des produits, il faut modifier les interfaces de l'usine abstraite et de l'usine spécifique.