抽象工厂模式介绍：

抽象工厂模式（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。

作者：Ferrari1001
链接：https://www.jianshu.com/p/0a4102b7f9d1