抽象工厂模式介绍：
抽象工厂模式（Abstract Factory Pattern）起源于以前对不同操作系统的图形化解决方案，如不同的操作系统中的按钮和文件框控件其实现不同，展示效果也不一样，对于每个操作系统，其本身就构成一个产品类，而按钮和文本框控件也构成一个产品类，两种产品类两种变化，各自有各自的特点，如Android 中的Button 和TextView，iOS中的Button 和 TextView，Windows Phone中的Button 和TextView等。
抽象工厂模式的定义：
为创建一组相关或是相互依赖的对象提供一个接口，而不需要指定它们的具体类。
抽象工厂模式的UML类图：
由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】抽象工厂方法模式的缺点：
一是类文件的爆炸性增加，二是不太容易扩展新的产品类，因为每当增加一个产品类就需要修改抽象工厂，那么所有的具体工厂类均会被修改。
