Patron de conception Fabrique abstraite

Le patron de conception Fabrique abstraite s'articule autour d'une super-fabrique qui crée d'autres fabriques. Cette super-fabrique est également appelée la fabrique des autres fabriques. Ce type de patron de conception appartient aux patrons de création, et il fournit un moyen optimal de créer des objets.

Dans le patron de conception Fabrique abstraite, l'interface est responsable de la création d'une fabrique d'objets liés sans spécifier explicitement leurs classes. Chaque fabrique générée peut fournir des objets selon le patron de conception Fabrique.

Le patron de fabrique abstraite fournit une interface pour créer une série d’objets liés ou interdépendants sans spécifier les classes d’implémentation concrètes. En utilisant le patron de fabrique abstraite, le client peut être découplé du processus de création des produits concrets, ce qui permet au client de créer une famille de produits via l’interface de fabrique.

summary

intention

Fournir une interface pour créer une série d’objets liés ou interdépendants sans spécifier leurs classes concrètes.

Résout principalement

Le problème de la sélection d’interface.

Scénarios applicables

Lorsque le système doit créer plusieurs objets liés ou dépendants sans spécifier les classes concrètes.

Solution

Plusieurs produits sont définis au sein d’une famille de produits, et les fabriques concrètes implémentent les méthodes de création de ces produits.

Code clé

Regrouper les méthodes de création de plusieurs produits similaires dans une seule fabrique.

Exemple d'application

Supposons qu’il existe différents types d’armoires ; chaque armoire (fabrique concrète) ne peut stocker qu’un seul type de vêtements (un ensemble complet de produits concrets), comme des tenues professionnelles, des tenues de mode, etc. Chaque ensemble de vêtements comprend des hauts et des pantalons spécifiques (produits concrets). Toutes les armoires sont des implémentations concrètes de la classe armoire (fabrique abstraite), et tous les hauts et pantalons implémentent respectivement l’interface de haut et l’interface de pantalon (produits abstraits).

Avantages

Garantir que les objets d’une même famille de produits fonctionnent ensemble.
Le client n’a pas besoin de connaître la classe concrète de chaque objet, ce qui simplifie le code.

Inconvénients

L'extension de la famille de produits est très difficile. L'ajout d'une nouvelle famille de produits nécessite de modifier le code de la fabrique abstraite et de toutes les fabriques concrètes.

Cas d'utilisation

Lorsque QQ change son habillage, l'ensemble des habillages est modifié en même temps.
Lors de la création d'applications multiplateformes, on génère des programmes pour différents systèmes d'exploitation.

Notes

Il est relativement facile d'ajouter une nouvelle famille de produits, mais il est plus difficile d'ajouter une nouvelle hiérarchie de produits.

Structure

Le patron Fabrique abstraite comprend les rôles principaux suivants :

Fabrique abstraite : déclare un ensemble de méthodes pour créer des objets produits, chaque méthode correspondant à un type de produit. La fabrique abstraite peut être une interface ou une classe abstraite.
Fabrique concrète : implémente l'interface de la fabrique abstraite et est responsable de la création d'instances d'objets produits concrets.
Produit abstrait : définit une interface commune ou une classe abstraite pour un ensemble d'objets produits, décrivant les méthodes publiques des objets produits.
Produit concret : implémente l'interface du produit abstrait, définissant le comportement et les attributs spécifiques du produit concret.

Le patron de fabrique abstraite implique généralement une famille de produits apparentés, et chaque classe de fabrique concrète est responsable de la création des produits concrets de cette famille. Le client crée des objets produits en utilisant l'interface de fabrique abstraite, sans utiliser directement les classes d'implémentation des produits concrets.

Implémentation

We will createShapeetColorinterfaces et des classes d'entité qui implémentent ces interfaces. L'étape suivante consiste à créer la classe de fabrique abstraiteAbstractFactory. Ensuite, définissez les classes de fabrique.ShapeFactoryetColorFactory, et ces deux classes de fabrique étendent toutes deuxAbstractFactory. Ensuite, créez une classe créatrice/génératrice de fabriqueFactoryProducer。

AbstractFactoryPatternDemoUtilisation de la classeFactoryProducerPour obtenirAbstractFactoryobjet. Il passera àAbstractFactoryPassez les informations de formeShape（CIRCLE / RECTANGLE / SQUARE), afin d'obtenir le type de l'objet dont il a besoin. En même temps, il fait également appel àAbstractFactoryPassez les informations de couleurColor（RED / GREEN / BLUE), afin d'obtenir le type de l'objet dont il a besoin.

Étape 1

Créez une interface pour les formes.

Shape.java

public interface Shape { void draw(); }

Étape 2

Créez des classes concrètes qui implémentent l'interface.

Rectangle.java

Rectangle.java

public class Rectangle implements Shape { @Override public void draw() { System.out.println("À l'intérieur de la méthode Rectangle::draw()."); } }

Square.java

public class Square implements Shape { @Override public void draw() { System.out.println("À l'intérieur de la méthode Square::draw()."); } }

Circle.java

public class Circle implements Shape { @Override public void draw() { System.out.println("À l'intérieur de la méthode Circle::draw()."); } }

Étape 3

Créer une interface pour les couleurs.

Color.java

public interface Color { void fill(); }

Étape 4

Créez des classes concrètes qui implémentent l'interface.

Red.java

public class Red implements Color { @Override public void fill() { System.out.println("À l'intérieur de la méthode Red::fill()."); } }

Green.java

public class Green implements Color { @Override public void fill() { System.out.println("À l'intérieur de la méthode Green::fill()."); } }

Blue.java

public class Blue implements Color { @Override public void fill() { System.out.println("À l'intérieur de la méthode Blue::fill()."); } }

Étape 5

Créer une classe abstraite pour obtenir des fabriques pour les objets Color et Shape.

AbstractFactory.java

public abstract class AbstractFactory { public abstract Color getColor(String color); public abstract Shape getShape(String shape); }

Étape 6

Créez des classes de fabrique qui étendent AbstractFactory, générant des objets de classes d'entité à partir des informations fournies.

ShapeFactory.java

public class ShapeFactory extends AbstractFactory { @Override public Shape getShape(String shapeType){ if(shapeType == null){ return null; } if(shapeType.equalsIgnoreCase("CIRCLE")){ return new Circle(); } else if(shapeType.equalsIgnoreCase("RECTANGLE")){ return new Rectangle(); } else if(shapeType.equalsIgnoreCase("SQUARE")){ return new Square(); } return null; } @Override public Color getColor(String color) { return null; } }

ColorFactory.java

public class ColorFactory extends AbstractFactory { @Override public Shape getShape(String shapeType){ return null; } @Override public Color getColor(String color) { if(color == null){ return null; } if(color.equalsIgnoreCase("RED")){ return new Red(); } else if(color.equalsIgnoreCase("GREEN")){ return new Green(); } else if(color.equalsIgnoreCase("BLUE")){ return new Blue(); } return null; } }

Étape 7

Créez une classe de création/génération de fabriques pour obtenir des fabriques en transmettant des informations sur la forme ou la couleur.

FactoryProducer.java

public class FactoryProducer { public static AbstractFactory getFactory(String choice){ if(choice.equalsIgnoreCase("SHAPE")){ return new ShapeFactory(); } else if(choice.equalsIgnoreCase("COLOR")){ return new ColorFactory(); } return null; } }

Étape 8

Utilisez FactoryProducer pour obtenir AbstractFactory, et obtenez des objets de classe d'entité en passant les informations de type.

AbstractFactoryPatternDemo.java

public class AbstractFactoryPatternDemo { public static void main(String[] args) { //Obtenez la fabrique de formes AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE"); //Obtenez l'objet avec la forme Circle Shape shape1 = shapeFactory.getShape("CIRCLE"); //Appelez la méthode draw de Circle shape1.draw(); //Obtenez un objet dont la forme est Rectangle Shape shape2 = shapeFactory.getShape("RECTANGLE"); //Appeler la méthode draw de Rectangle shape2.draw(); //Obtenir l'objet avec la forme Square Shape shape3 = shapeFactory.getShape("SQUARE"); //Appeler la méthode draw de Square shape3.draw(); //Obtenir la fabrique de couleurs AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR"); //Obtenir l'objet avec la couleur Red Color color1 = colorFactory.getColor("RED"); //Appeler la méthode fill de Red color1.fill(); //Obtenir l'objet avec la couleur Green Color color2 = colorFactory.getColor("GREEN"); //Appeler la méthode fill de Green color2.fill(); //Obtenir les objets dont la couleur est Blue Color color3 = colorFactory.getColor("BLUE"); //Appeler la méthode fill de Blue color3.fill(); } }

Étape 9

Exécutez le programme, affichez le résultat :

Inside Circle::draw() method.
Inside Rectangle::draw() method.
Inside Square::draw() method.
Inside Red::fill() method.
Inside Green::fill() method.
Inside Blue::fill() method.

autres extensions

Patrons de conceptionAutres