抽象工厂模式

抽象工厂模式:

抽象工厂模式:

（使用抽象类创建一个工厂，此工厂生产多类产品，每个产品对于一个继承此工厂的具体工厂类，在使用工厂生成器产生不同的工厂，根据工厂产生产品）
抽象工厂模式（Abstract Factory），提供一个创建一系列相关或互相依赖对象的接口，而无需指定它们具体的类。

与工厂模式的区别：

这两种设计模式主要的区别在于产品，工厂模式是用来创建同一个产品的不同类型的（详情请看上一篇博客中卖包子的案例，大肉包和牛肉包它们都是包子的不同类型展示），但是抽象工厂模式是用来创建不同类的产品，比如包子店还卖豆浆油条。一般来说，产品种类单一，适合用工厂模式；如果有多个种类，各种类型时，通过抽象工厂模式来进行创建是很合适的

意图：

提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

主要解决：

主要解决接口选择的问题。

何时使用：

系统的产品有多于一个的产品族，而系统只消费其中某一族的产品。

如何解决：

在一个产品族里面，定义多个产品。

关键代码：

在一个工厂里聚合多个同类产品。 优点：当一个产品族中的多个对象被设计成一起工作时，它能保证客户端始终只使用同一个产品族中的对象。

缺点：

产品族扩展非常困难，要增加一个系列的某一产品，既要在抽象的 Creator 里加代码，又要在具体的里面加代码。

使用场景：

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

注意事项：

产品族难扩展，产品等级易扩展。

实现:

我们将创建 Shape 和 Color 接口和实现这些接口的实体类。下一步是创建抽象工厂类 AbstractFactory。接着定义工厂类；ShapeFactory 和 ColorFactory，这两个工厂类都是扩展了； AbstractFactory。然后创建一个工厂创造器/生成器类 FactoryProducer； AbstractFactoryTestDemo，我们的演示类使用 FactoryProducer 来获取 AbstractFactory对象。它将向 AbstractFactory 传递形状信息 Shape（CIRCLE / RECTANGLE / SQUARE），以便获取它所需对象的类型。同时它还向 AbstractFactory 传递颜色信息 Color（RED / GREEN / BLUE），以便获取它所需对象的类型。

步骤一：创建两个产品接口

/**
 * shape产品
 */
public interface Shape {
    void draw();
}

/**
 * Color产品
 */
public interface Color {
    void fill();
}

步骤二：创建产品实现类

1.shape产品具体实现类

/**
 * 具体实现类Rectangle
 */
class Rectangle implements Shape{


    @Override
    public void draw() {
        System.out.println("use Rectangle draw()!");
    }
}


/**
 * 具体实现类Square
 */
class Square implements Shape{
    @Override
    public void draw() {
        System.out.println("use Square draw()!");
    }
}



/**
 * 具体实现类Circle
 */
class Circle implements Shape{
    @Override
    public void draw() {
        System.out.println("use Circle draw()!");
    }
}

2.color产品具体实现类

/**
 * 具体实现类Red
 */
class Red implements Color{

    @Override
    public void fill() {
        System.out.println("use Red fill()!");
    }
}

/**
 * 具体实现类Green
 */
class Green  implements Color{

    @Override
    public void fill() {
        System.out.println("use Green  fill()!");
    }
}


/**
 * 具体实现类Blue
 */
class Blue   implements Color{

    @Override
    public void fill() {
        System.out.println("use Blue   fill()!");
    }
}

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

/**
 * 抽象工厂模式
 */
public abstract class AbstractFactory {
    public abstract Shape  getShape(String shapeType);
    public abstract Color  getColor(String colorType);
}

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

/**
 * ShapeFactroy工厂
 */
public class ShapeFactroy extends AbstractFactory{
    public Shape getShape(String shapeTye){
        if(shapeTye==null){
            return null;
        }
        if(shapeTye.equalsIgnoreCase("Circle")){
            return new Circle();
        }
        else if(shapeTye.equalsIgnoreCase("Rectangle")){
            return new Rectangle();
        }

        else if(shapeTye.equalsIgnoreCase("Square")){
            return new Square();
        }
        return null;
    }

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

/**
 * ColorFactory工厂：获得shape产品和color产品
 */
public class ColorFactory extends AbstractFactory {
    @Override
    public Shape getShape(String shapeType) {
        return null;
    }

    @Override
    public Color getColor(String colorType) {
        if(colorType==null){
            return null;
        }
        if(colorType.equalsIgnoreCase("red")){
            return new Red();
        }else if (colorType.equalsIgnoreCase("green")){
            return new Green();
        }else if(colorType.equalsIgnoreCase("blue")){
            return new Blue();
        }
        return null;
    }
}

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

/**
 * 工厂生成器
 */
public class FactroyProducer {
    public static AbstractFactory getFactory(String factoryType){
        if(factoryType.equalsIgnoreCase("Shape")){
            return new ShapeFactroy();
        }else if(factoryType.equalsIgnoreCase("Color")){
            return new ColorFactory();
        }
        return null;
    }
}

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

public class AbstractFactoryTestDemo {
    public static void main(String[] args) {
        //获取shapeFactroy工厂
        AbstractFactory shapeFactroy = FactroyProducer.getFactory("Shape");

        //获取 Circle 的对象，并调用它的 draw 方法
        Shape circle = shapeFactroy.getShape("Circle");
        circle.draw();
        //获取 Rectangle 的对象，并调用它的 draw 方法
        Shape rectangle = shapeFactroy.getShape("Rectangle");
        rectangle.draw();
        //获取 Square 的对象，并调用它的 draw 方法
        Shape square = shapeFactroy.getShape("Square");
        square.draw();

        //获取colorFactroy工厂
        AbstractFactory colorFactroy = FactroyProducer.getFactory("Color");
        //获取 Red 的对象，并调用它的 fill 方法
        Color red = colorFactroy.getColor("Red");
        red.fill();
        //获取 Green 的对象，并调用它的 fill 方法
        Color green = colorFactroy.getColor("Green");
        green.fill();
        //获取 Blue 的对象，并调用它的 fill 方法
        Color blue = colorFactroy.getColor("Blue");
        blue.fill();
    }
}
输出结果：
use Circle draw()!
use Rectangle draw()!
use Square draw()!
use Red fill()!
use Green  fill()!
use Blue   fill()!