抽象工厂模式

1、抽象工厂模式的概念

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

在抽象工厂模式中，接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。每个生成的工厂都能按照工厂模式提供对象。

2、抽象工厂模式的特点

• 接口是负责创建一个相关对象的工厂，不需要显式指定它们的类。
• 每个生成的工厂都能按照工厂模式提供对象。

3、关于抽象工厂模式

• 目的：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
• 解决问题：主要解决接口选择的问题。
• 使用时机：系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。
• 保证该模式：在一个产品族里面，定义多个产品。
• 关键：在一个工厂里聚合多个同类产品。

4、优缺点

• 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。
• 缺点：产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的Creator里加代码，又要在具体的里面加代码。

5、使用场景

• QQ换皮肤，一整套一起换。
• 生成不同操作系统的程序。

注意：产品族难扩展，产品等级易扩展。

6、抽象工厂模式的实现

将创建Shape和Color接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类ShapeFactory和ColorFactory，这两个工厂类都是扩展了AbstractFactory。然后创建一个工厂创造器/生成器类FactoryProducer。

AbstractFactoryPatternDemo类使用 FactoryProducer来获取AbstractFactory对象。它将向AbstractFactory传递形状信息Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向AbstractFactory传递颜色信息Color（RED / GREEN / BLUE），以便获取它所需对象的类型。如下图：

（1）创建Shape接口及实现类

创建Shape接口：

public interface Shape {
    
    //定义一个抽象方法
    void draw();

}

创建实现类：

public class Rectangle implements Shape{

    @Override
    public void draw() {
      System.out.println("调用内矩形的draw方法！");  
    }

}

public class Square implements Shape{

    @Override
    public void draw() {
        System.out.println("调用正方形的draw方法！"); 
    }

}

public class Circle implements Shape{

    @Override
    public void draw() {
        System.out.println("调用圆形的draw方法！");
    }

}

（1）创建Color接口及实现类

创建Color接口：

public interface Color {
    
    //定义抽象方法
    void fill();

}

创建实现类：

public class Red implements Color{

    @Override
    public void fill() {
       System.out.println("填充红色！"); 
    }

}

public class Green implements Color{

    @Override
    public void fill() {
       System.out.println("填充绿色！"); 
    }

}

public class Blue implements Color{

    @Override
    public void fill() {
       System.out.println("填充蓝色！"); 
    }

}

（3）创建抽象类

为Color和Shape对象创建抽象类来获取工厂：

/*
 * 抽象工厂类
 */
public abstract class AbstractFactory {
    
    //定义抽象方法，返回Shape接口
    public abstract Shape getShape(String type);
    
    //定义抽象方法，返回Color接口
    public abstract Color getColor(String color);

}

（4）创建工厂类的扩展类

创建扩展了AbstractFactory的工厂类，基于给定的信息生成实体类的对象。

创建Shape工厂，该工厂是AbstractFactory的子类：

/*
 * Shape工厂类
 */
public class ShapeFactory extends AbstractFactory {

    @Override
    public Shape getShape(String type) {
        if (type == null) {
            return null;
        }
        // 判断具体是哪种类型
        if (type.equalsIgnoreCase("RECTANGLE")) {
            return new Rectangle();
        } else if (type.equalsIgnoreCase("SQUARE")) {
            return new Square();
        } else if (type.equalsIgnoreCase("CIRCLE")) {
            return new Circle();
        } else {
            return null;
        }
    }

    @Override
    public Color getColor(String color) {
        return null;
    }

}

创建Color工厂，该工厂是AbstractFactory的子类：

/*
 * Color工厂类
 */
public class ColorFactory extends AbstractFactory {

    @Override
    public Shape getShape(String type) {
        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();
        } else {
            return null;
        }
    }

}

（5）创建工厂生产类

创建一个工厂创造器/生成器类，通过传递形状或颜色信息来获取工厂：

/*
 * 工厂生产类，用于生产工厂
 */
public class FactoryProducer {

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

}

（6）测试

使用FactoryProducer来获取AbstractFactory，通过传递类型信息来获取实体类的对象：

public class TestAbstractFactory {

    public static void main(String[] args) {
        // 获取Shape工厂
        AbstractFactory shapeFactory = FactoryProducer.getFactory("SHAPE");
        // 获取Rectangle对象
        Shape s0 = shapeFactory.getShape("RECTANGLE");
        s0.draw();
        // 获取Square对象
        Shape s2 = shapeFactory.getShape("SQUARE");
        s2.draw();
        // 获取Circle对象
        Shape s3 = shapeFactory.getShape("CIRCLE");
        s3.draw();
        // 获取Color工厂
        AbstractFactory colorfaFactory = FactoryProducer.getFactory("COLOR");
        // 获取Red对象
        Color c0 = colorfaFactory.getColor("RED");
        c0.fill();
        // 获取Green对象
        Color c2 = colorfaFactory.getColor("GREEN");
        c2.fill();
        // 获取Blue对象
        Color c3 = colorfaFactory.getColor("BLUE");
        c3.fill();
    }

}

执行，控制台输出如下：

7、总结

抽象工厂模式与工厂模式类似，但是加了一个抽象工厂类来获取工厂类接口，不需要显式指定它们的类，然后提供给一个工厂生产类专门用来生产工厂。