抽象工厂模式

抽象工厂模式介绍：

抽象工厂模式（Abstract Factory Pattern）起源于以前对不同操作系统的图形化解决方案，如不同的操作系统中的按钮和文件框控件其实现不同，展示效果也不一样，对于每个操作系统，其本身就构成一个产品类，而按钮和文本框控件也构成一个产品类，两种产品类两种变化，各自有各自的特点，如Android 中的Button 和TextView，iOS中的Button 和 TextView，Windows Phone中的Button 和TextView等。

抽象工厂模式的定义：

为创建一组相关或是相互依赖的对象提供一个接口，而不需要指定它们的具体类。

抽象工厂模式的UML类图：

image.png

由UML图可以得出如下抽象工厂模式的通用模式代码。

抽象产品类A

/**
 * @ClassName AbstractProductA
 * @Description 抽象产品类A
 * @Author lm
 * @Date 2018/9/13 0013 23:51
 * @Version 1.0
 **/
public abstract class AbstractProductA {
    /**
     * 每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

抽象产品类B

/**
 * @ClassName AbstractProductB
 * @Description 抽象产品类B
 * @Author lm
 * @Date 2018/9/13 0013 23:53
 * @Version 1.0
 **/
public abstract class AbstractProductB {
    /**
     * 每个具体的产品子类需要实现的方法
     */
    public abstract void method();
}

具体产品类A1

/**
 * @ClassName ConcreteProductA1
 * @Description 具体产品类A1
 * @Author lm
 * @Date 2018/9/13 0013 23:55
 * @Version 1.0
 **/
public class ConcreteProductA1 extends AbstractProductA {

    @Override
    public void method() {
        System.out.println("具体产品A1的方法");
    }
}

具体产品类A2

/**
 * @ClassName ConcreteProductA2
 * @Description 具体产品类A2
 * @Author lm
 * @Date 2018/9/13 0013 23:55
 * @Version 1.0
 **/
public class ConcreteProductA2 extends AbstractProductA {

    @Override
    public void method() {
        System.out.println("具体产品A2的方法");
    }
}

具体产品类B1

/**
 * @ClassName ConcreteProductB1
 * @Description 具体产品类B1
 * @Author lm
 * @Date 2018/9/13 0013 23:55
 * @Version 1.0
 **/
public class ConcreteProductB1 extends AbstractProductB {

    @Override
    public void method() {
        System.out.println("具体产品B1的方法");
    }
}

具体产品类B2

**
 * @ClassName ConcreteProductB2
 * @Description 具体产品类B2
 * @Author lm
 * @Date 2018/9/13 0013 23:55
 * @Version 1.0
 **/
public class ConcreteProductB2 extends AbstractProductB {

    @Override
    public void method() {
        System.out.println("具体产品B2的方法");
    }
}

抽象工厂类

/**
        * @ClassName AbstractFactory
        * @Description TODO
        * @Author lm
        * @Date 2018/9/14 0014 0:03
        * @Version 1.0
        **/
public abstract class AbstractFactory {
    /**
     * 创建产品A的方法
     * return 产品A对象
     */
    public abstract AbstractProductA createProductA();

    /**
     * 创建产品B的方法
     * return 产品B对象
     */
    public abstract AbstractProductB createProductB();

}

具体工厂类1

/**
 * @ClassName ConcreteFactory1
 * @Description 具体工厂类1
 * @Author lm
 * @Date 2018/9/14 0014 0:06
 * @Version 1.0
 **/
public class ConcreteFactory1 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA1();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB1();
    }
}

具体工厂类2

/**
 * @ClassName ConcreteFactory2
 * @Description 具体工厂类2
 * @Author lm
 * @Date 2018/9/14 0014 0:06
 * @Version 1.0
 **/
public class ConcreteFactory2 extends AbstractFactory {
    @Override
    public AbstractProductA createProductA() {
        return new ConcreteProductA2();
    }

    @Override
    public AbstractProductB createProductB() {
        return new ConcreteProductB2();
    }
}

抽象工厂模式的主要角色类：

【1】AbstractFactory:

抽象工厂角色，它声明了一组用于创建一种产品的方法，每一个方法对应一种产品，如上述类图中的AbstractFactory中就定义了两种方法，分别创建产品A和产品B。

【2】ConcreteFactory:

具体工厂角色，它实现了在抽象工厂中定义的创建产品的方法，生成一组具体产品，这些产品构成了一个产品种类，每一个产品都位于某个产品等级结构中，如上述类图中的ConcreteFactory1和ConcreteFactory2。

【3】AbstractProduct:

抽象产品角色，它为每种产品声明接口，比如上述类图中的AbstractProductA和AbstractProductB。

【4】ConcreteProduct:

具体产品角色，它定义具体工厂生产的具体产品对象，实现抽象产品接口中声明的业务方法，如上述类图中的ConcreteProductA1、ConcreteProductA2、ConcreteProductB1、ConcreteProductB2。

总结：

【1】抽象工厂方法模式的优点：
一个显著的优点是分离接口与实现，客户端使用抽象工厂来创建需要的对象，而客户端根本就不知道具体的实现是谁，客户端只是面向产品的接口编程而已，使其从具体的产品实现中解耦，同时基于接口与实现的分离，使抽象该工厂方法模式在切换产品类时更加灵活，容易。
【2】抽象工厂方法模式的缺点：
一是类文件的爆炸性增加，二是不太容易扩展新的产品类，因为每当增加一个产品类就需要修改抽象工厂，那么所有的具体工厂类均会被修改。