[Notes de modèle de conception] Modèle d'usine abstrait

Créer d'autres usines autour d'une gigafactory. La Gigafactory est également connue comme l'usine des autres usines.

Fournit un moyen optimal de créer des objets.

Dans le modèle de fabrique abstraite, une interface est une fabrique responsable de la création d'un objet connexe, sans qu'il soit nécessaire de spécifier explicitement sa classe.

Chaque usine générée peut fournir des objets selon le modèle d'usine.

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ésoudre le problème : résoudre principalement le problème de la sélection de l'interface

Code clé : Agréger plusieurs produits du même type dans une seule usine

AbstractFactory {
    getA;
    getB;

}

AFactory extends AbsFactory{getA,getB};
BFactory extends AbsFactory{getA,getB};

AbstractFactory Afactory=FactoryProducer.getFactory("A");
A a=Afactory.getA;

AbstractFactory Bfactory=FactoryProducer.getFactory("B");
B b=Bfactory.getB;

 

Avantage : lorsque plusieurs objets d'une famille de produits sont conçus pour fonctionner ensemble, cela garantit que les clients n'utilisent toujours que des objets de la même famille de produits

Inconvénients : Il est très difficile d'élargir la famille de produits.Pour ajouter un certain produit dans une série, il est nécessaire d'ajouter du code dans l'abstrait Creator et d'ajouter du code dans celui spécifique.

Scénario d'utilisation : changement de peau QQ, un ensemble complet change ensemble

Code de cas :

Créez une interface de forme :

public interface Shape {
    void draw();
}

Classe d'implémentation de forme :

public class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("circle draw");
    }
}

public class Rectangle implements Shape{
    @Override
    public void draw() {
        System.out.println("rectangle draw");
    }
}

public class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("Square draw");
    }
}

Créez une interface pour les couleurs :

public interface Color {
    void fill();
}

public class Red implements Color{
    @Override
    public void fill() {
        System.out.println("red fill");
    }
}

public class Blue implements Color{
    @Override
    public void fill() {
        System.out.println("Blue fill");
    }
}

public class Green implements Color{
    @Override
    public void fill() {
        System.out.println("Green fill");
    }
}

Créez des classes abstraites pour les objets de couleur et de forme afin d' obtenir des fabriques :

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

Hériter de la classe de fabrique abstraite et générer des objets de classe d'entité en fonction des informations fournies

public class ShapeFactory extends AbstractFactory{
    @Override
    public Color getColor(String color) {
        return null;
    }

    @Override
    public Shape getShape(String shape) {
        if(shape==null)return null;
        if(shape.equalsIgnoreCase("circle")){
            return new Circle();
        }else if(shape.equalsIgnoreCase("rectangle")){
            return new Rectangle();
        }else if(shape.equalsIgnoreCase("square")){
            return new Square();
        }
        return null;
    }
}

public class ColorFactory extends AbstractFactory{
    @Override
    public Color getColor(String color) {
        if(color==null)return null;
        else 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;
    }
    @Override
    public Shape getShape(String shape) {
        return null;
    }
}

Créez une classe de créateur/générateur d'usine pour obtenir l'usine en transmettant des informations de forme ou de couleur

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;
    }
}

test:

public class AbstractFactoryPattrnDemo {
    public static void main(String[] args) {
        AbstractFactory shape = FactoryProducer.getFactory("shape");
        shape.getShape("circle").draw();
        shape.getShape("rectangle").draw();
        shape.getShape("square").draw();

        AbstractFactory color = FactoryProducer.getFactory("color");
        color.getColor("red").fill();
        color.getColor("green").fill();
        color.getColor("blue").fill();
    }
}