[Notas del patrón de diseño] Patrón de fábrica abstracto

Crea otras fábricas alrededor de una gigafábrica. La Gigafábrica también se conoce como la fábrica de otras fábricas.

Proporciona una forma óptima de crear objetos.

En el patrón de fábrica abstracta, una interfaz es una fábrica responsable de crear un objeto relacionado, sin necesidad de especificar explícitamente su clase.

Cada fábrica generada puede proporcionar objetos de acuerdo con el patrón de fábrica.

Propósito: proporcionar una interfaz para crear una serie de objetos relacionados o interdependientes sin especificar sus clases concretas

Resolver el problema: resolver principalmente el problema de la selección de interfaz

Código clave: Agrega múltiples productos del mismo tipo en una fábrica

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;

 

Ventaja: cuando se diseñan varios objetos de una familia de productos para que funcionen juntos, se garantiza que los clientes siempre usen solo objetos de la misma familia de productos

Desventajas: Es muy difícil ampliar la familia de productos, para agregar un determinado producto en una serie, es necesario agregar código en el creador abstracto y agregar código en el específico.

Escenario de uso: cambio de piel QQ, un conjunto completo de cambios juntos

Código de caso:

Crear una interfaz de forma:

public interface Shape {
    void draw();
}

Clase de implementación de forma:

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

Crea una interfaz para los colores:

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

Cree clases abstractas para objetos de color y forma para obtener fábricas:

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

Herede la clase de fábrica abstracta y genere objetos de clase de entidad en función de la información proporcionada

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

Cree una clase de creador/generador de fábrica para obtener la fábrica pasando información de forma o color

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

prueba:

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