前言

抽象工厂模式（Abstract Factory Pattern）是围绕一个超级工厂创建其他工厂。该超级工厂又称为其他工厂的工厂。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。

次前言

后期检查时，发现这里不小心把Rectangle翻译成了三角形。所以这里特意提出了。Rectangle本意是长方形。

抽象工厂类图关系示例

关系更清晰的图：

类图解释

Main中new一个Produce对象即超级工厂对象，Produce对象可以根据当前参数决定到底应该选择哪个工厂，选择好工厂后，在对应的工厂类中，可以顺利的拿到想要的对象。

代码部分

主类Main

public class Main {
    public static void main(String[] args){
        //拿到能生产工厂的对象
        Produce produce = new Produce();

        AbstractFactory shapeFactory = produce.getFactory("SHAPE");

        Shape shape1 = shapeFactory.getShape("圆");
        shape1.draw();

        Shape shape2 = shapeFactory.getShape("三角形");
        shape2.draw();

        Shape shape3 = shapeFactory.getShape("正方形");
        shape3.draw();

        AbstractFactory colorFactory = produce.getFactory("COLOR");

        Color color1 = colorFactory.getColor("RED");
        color1.fill();

        Color color2 = colorFactory.getColor("GREEN");
        color2.fill();

        Color color3 = colorFactory.getColor("BLUE");
        color3.fill();
    }
}

能拿到各个工厂的超级工厂 Produce类

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

工厂与工厂之间的关系

首先是抽象工厂类。

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

多个工厂类的实现。（2个）

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.equals("圆")){
            return new Circle();
        } else if(shape.equals("三角形")){
            return new Rectangle();
        } else if(shape.equals("正方形")){
            return new Square();
        }
        return null;
    }
}

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.equals("RED")) {
            return new Red();
        } else if (color.equals("GREEN")) {
            return new Green();
        } else if (color.equals("BLUE")) {
            return new Blue();
        }
        return null;
    }
}

接下来就是两个工厂中，应该生产的对象。

首先是接口（2个）

public interface Shape {
    void draw();
}

public interface Color {
    void fill();
}

然后是2个产品中，具体的类的实现。（6个实现类）

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

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

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

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

public class Rectangle implements Shape {
    @Override
    public void draw() {
        System.out.println("画三角形");
    }
}

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

最终main函数运行结果

画圈圈
画三角形
画正方形.
要红色
要绿色
要蓝色

总结

最明显的能感受到，在工厂模式的条件下，进一步升级。抽象工厂有一个超级工厂，是可以用来生产工厂的。然后生产出来的工厂再去生产产品，进一步进行了抽取。而工厂模式直接造出