modèle d'usine abstrait
Abstract Factory Pattern consiste à créer d’autres usines autour d’une super usine. La Gigafactory est également connue comme l’usine des autres usines. Ce type de modèle de conception est un modèle de création qui offre une manière optimale de créer des objets.
Dans le modèle de fabrique abstraite, l'interface est une fabrique chargée de créer un objet associé sans spécifier explicitement sa classe. Chaque usine générée peut fournir des objets selon le modèle d'usine.
Introduction
Intention : Fournit 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 : Résout principalement le problème de la sélection de l'interface.
Quand utiliser : Les produits du système ont plus d'une famille de produits, et le système ne consomme que les produits d'une des familles.
Comment résoudre : Définissez plusieurs produits dans une famille de produits.
Code clé : Agrégation de plusieurs produits similaires dans une usine.
Exemples d'application : Après le travail, pour assister à certaines soirées, vous devez avoir deux ou plusieurs ensembles de vêtements, comme des vêtements de travail (ensembles complets, une série de produits spécifiques), vêtements de mode (Ensembles complets, une série de produits spécifiques), même pour une famille, il peut y avoir des vêtements pour femmes d'affaires, des vêtements pour hommes d'affaires, des vêtements pour femmes à la mode, des vêtements pour hommes à la mode, ce sont aussi des ensembles complets, c'est-à-dire une série de vêtements spécifiques produits. Supposons une situation (qui n'existe pas dans la réalité, sinon il n'y a aucun moyen d'entrer dans le communisme, mais il est utile d'illustrer le modèle abstrait de l'usine). Dans votre maison, une certaine armoire (usine à béton) ne peut stocker qu'un certain type). de tels Vêtements (ensemble, une série de produits spécifiques), chaque fois que vous récupérerez cet ensemble de vêtements, vous les sortirez naturellement de cette armoire. Utilisez la pensée OO pour comprendre que toutes les armoires (usines à béton) sont des armoires (usines abstraites), et que chaque ensemble de vêtements comprend des hauts spécifiques (un produit spécifique), des pantalons (un produit spécifique), ces hauts en béton sont en fait des hauts (un produit abstrait), et le pantalon en béton est aussi un pantalon (un autre produit abstrait).
Avantages : Lorsque plusieurs objets d'une famille de produits sont conçus pour fonctionner ensemble, cela peut garantir que le client n'utilise toujours que des objets de la même famille de produits.
Inconvénients : L'expansion d'une famille de produits est très difficile. Pour ajouter un certain produit d'une série, vous devez ajouter du code au créateur abstrait ainsi qu'au spécifique.
Scénarios d'utilisation : 1. Changement de peau QQ, l'ensemble est modifié ensemble. 2. Générez des programmes pour différents systèmes d'exploitation.
Remarques : Les familles de produits sont difficiles à étendre, mais les niveaux de produits sont faciles à étendre.
Implémentation
Nous allons créer les interfaces Shape et Color et les classes d'entités qui implémentent ces interfaces. L'étape suivante consiste à créer la classe d'usine abstraite AbstractFactory. Définissez ensuite les classes d'usine ShapeFactory et ColorFactory, qui étendent toutes deux AbstractFactory. Créez ensuite une classe de créateur/générateur d'usine FactoryProducer.
AbstractFactoryPatternDemo, notre classe de démonstration utilise FactoryProducer pour obtenir l'objet AbstractFactory. Il transmettra les informations de forme Shape (CIRCLE / RECTANGLE / SQUARE) à l'AbstractFactory afin d'obtenir le type d'objet dont il a besoin. Il transmet également les informations de couleur Color (RED / GREEN / BLUE) à AbstractFactory afin d'obtenir le type d'objet dont il a besoin.
Étape 1
Créez une interface pour la forme.
Shape.java
public interface Shape {
void draw();
}Étape 2
Créez une classe d'entité qui implémente l'interface.
Rectangle.java
public class Rectangle implements Shape {
@Override
public void draw() {
System.out.println("Inside Rectangle::draw() method.");
}
}Carré.java
public class Square implements Shape {
@Override
public void draw() {
System.out.println("Inside Square::draw() method.");
}
}Circle.java
public class Circle implements Shape {
@Override
public void draw() {
System.out.println("Inside Circle::draw() method.");
}
}Étape 3
Créez une interface pour la couleur.
Color.java
public interface Color {
void fill();
}Étape 4
Créez une classe d'entité qui implémente l'interface.
Rouge.java
public class Red implements Color {
@Override
public void fill() {
System.out.println("Inside Red::fill() method.");
}
}Vert.java
public class Green implements Color {
@Override
public void fill() {
System.out.println("Inside Green::fill() method.");
}
}Bleu.java
public class Blue implements Color {
@Override
public void fill() {
System.out.println("Inside Blue::fill() method.");
}
}Étape 5
Créez des classes abstraites pour les objets Color et Shape afin d'obtenir des usines.
AbstractFactory.java
public abstract class AbstractFactory {
abstract Color getColor(String color);
abstract Shape getShape(String shape) ;
}Étape 6
Créez une classe d'usine qui étend AbstractFactory pour générer des objets de classes d'entités en fonction 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
Color getColor(String color) {
return null;
}
}ColorFactory.java
public class ColorFactory extends AbstractFactory {
@Override
public Shape getShape(String shapeType){
return null;
}
@Override
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éer une usine Créer Une classe générateur/générateur qui obtient l'usine en transmettant des informations de forme ou de 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 obtenir l'objet de la classe d'entité en transmettant les informations de type.
AbstractFactoryPatternDemo.java
public class AbstractFactoryPatternDemo {
public static void main(String[] args) {
//获取形状工厂
AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
//获取形状为 Circle 的对象
Shape shape1 = shapeFactory.getShape("CIRCLE");
//调用 Circle 的 draw 方法
shape1.draw();
//获取形状为 Rectangle 的对象
Shape shape2 = shapeFactory.getShape("RECTANGLE");
//调用 Rectangle 的 draw 方法
shape2.draw();
//获取形状为 Square 的对象
Shape shape3 = shapeFactory.getShape("SQUARE");
//调用 Square 的 draw 方法
shape3.draw();
//获取颜色工厂
AbstractFactory colorFactory = FactoryProducer.getFactory("COLOR");
//获取颜色为 Red 的对象
Color color1 = colorFactory.getColor("RED");
//调用 Red 的 fill 方法
color1.fill();
//获取颜色为 Green 的对象
Color color2 = colorFactory.getColor("Green");
//调用 Green 的 fill 方法
color2.fill();
//获取颜色为 Blue 的对象
Color color3 = colorFactory.getColor("BLUE");
//调用 Blue 的 fill 方法
color3.fill();
}
}Étape 9
Vérifiez la sortie.
Inside Circle::draw() method. Inside Rectangle::draw() method. Inside Square::draw() method. Inside Red::fill() method. Inside Green::fill() method. Inside Blue::fill() method.
