意图
提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。
适用性
在以下情况可以使用 Abstract Factory模式
• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。
结构
模式结构图如下所示：
aaarticlea/png;base64,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" alt="" />
Creator: 声明一个创建抽象产品对象的操作接口。
ConcreteCreator:(ConcreteCreator1,ConcreteCreator2):实现创建具体产品对象的操作。
Product(ProductA,ProductB):为一类产品对象声明一个接口。
ConcreteProduct(ProductA1,ProductA2,ProductB1,ProductB2):定义一个将被相应的具体工厂创建的产品对象。实现 Product接口。
Client:仅使用由Creator和Product类声明的接口。
协作
通常在运行时刻创建一个 ConcreteFactroy类的实例。这一具体的工厂创建具有特定实现的产品对象。为创建不同的产品对象，客户应使用不同的具体工厂。
AbstractFactory将产品对象的创建延迟到它的 ConcreteFactroy子类。
效 果
AbstractFactory模式有下面的一些优点和缺点：
1) 它分离了具体的类 Abstract Factory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码中。
2) 它使得易于交换产品系列 一个具体工厂类在一个应用中仅出现一次—即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变。
3) 它有利于产品的一致性 当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而 AbstractFactory很容易实现这一点。
4) 难 以 支 持 新 种 类 的 产 品 难以扩展抽象工厂以生产新种类的产品。这是因为AbstractFactory接口确定了可以被创建的产品集合。 支持新种类的产品就需要扩展该工厂接口，这将涉及AbstractFactory类及其所有子类的改变。我们会在实现一节讨论这个问题的一个解决办法。
实 现
下面是实现Abstract Factor模式的一些有用技术：
1) 将工厂作为单件 一个应用中一般每个产品系列只需一个 ConcreteFactroy的实例。因此工厂通常最好实现为一个 Singleton。
2) 创建产品 AbstractFactory仅声明一个创建产品的接口，真正创建产品是由 ConcreteProduct子类实现的。最通常的一个办法是为每一个产品定义一个工厂方法。一个具体的工厂将为每个产品重定义该工厂方法以指定产品。虽然
这样的实现很简单，但它却要求每个产品系列都要有一个新的具体工厂子类，即使这些产品系列的差别很小。
如果有多个可能的产品系列，具体工厂也可以使用 Prototype模式来实现。具体工厂使用产品系列中每一个产品的原型实例来初始化，且它通过复制它的原型来创建新的产品。在基于原型的方法中，使得不是每个新的产品系列都需要一个新的具体工厂类。
JAVA集合框架中抽象模式的应用。
下面部分摘录自大神左潇龙博客抽象工厂模式详解
在集合框架里，有一个不太明显的抽象工厂模式，就是List接口，它在iterable的基础上，扩展了一个创建产品的方法，本次以List接口为例，我们来看看List接口的源码。
package java.util;
public interface List<E> extends Collection<E> {
Iterator<E> iterator();//一种产品
Object[] toArray();
<T> T[] toArray(T[] a);
ListIterator<E> listIterator();//另外一种产品
ListIterator<E> listIterator(int index);
}
LZ去掉了List接口中的很多方法，一是为了节省版面，另外是为了更清晰，我们主要关注iterator和listIterator方法，LZ在上面加了标注。
其中ListIterator是Iterator的子接口，但归根到底，它其实属于另外一种产品，为什么这么说呢，ListIterator不是Iterator的子接口吗，怎么能算是另外一种产品呢？这是因为我们listIterator方法的返回类型是ListIterator，而不是Iterator，所以两者的功能是不同的，比如ListIterator还可以向前移动。
我们可以认为这两个方法产生的一个是只能向后移动的迭代器，一个是可以前后移动的迭代器，这算是两种产品，相当于上面的ProductA和ProductB。
这个设计可以看做是一个抽象工厂模式，List接口定义了两种生产不同产品的方法，这属于两个系列的产品，不过由于产品接口本身的继承关系，两者的实现类也会被做成继承的关系。下面给出上面提到的接口的UML图。
这个图看起来有点复杂，各位可以和上面标准的抽象工厂模式类图对比一下，下面LZ来解释一下在抽象工厂模式当中，上述几个类都代表的什么角色。
1.List，是抽象工厂的角色，它有两个制造产品的方法，iterator和listIterator，相当于Creator。
2.ListIterator和Iterator都是抽象产品，相当于ProductA和ProductB。其中ListIterator有两个实现类，分别是AbstractList.ListItr和LinkedList.ListItr，相当于ProductA1和ProductA2。Iterator的实现类为AbstractList.Itr，相当于ProductB1，但是没有B2。
3.LinkedList是其中一个具体的工厂类，相当于ConcreteCreator1，实现抽象工厂List，它制造的两个具体产品分别是LinkedList.ListItr和AbstractList.Itr。
4.同样的，ArrayList也是一个具体的工厂类，相当于ConcreteCreator2，实现抽象工厂List，它制造的两个具体产品分别是AbstractList.ListItr和AbstractList.Itr。
我们来分析一下工厂方法模式和抽象工厂模式二者的关系。
Iterable接口是List的父接口，所以它只负责一个产品Iterator的制造，所以是工厂方法模式，而List接口扩展了Iterable接口，又添加了一个制造产品的方法，即又添加了一个系列的产品，所以就成为了抽象工厂模式。
LZ下面给出上述两个类图的对应关系,会让各位看的更加清晰：
1.Creator=List
2.ConcreteCreator1=ArrayList
3.ConcreteCreator2=LinkedList
4.ProductA=Iterator
5.ProductB=ListIterator
6.ProductA1=AbstractList.Itr
7.ProductA2=无（具体的A产品2在第一个类图中是没有的，但这并不影响整个体系）
8.ProductB1=AbstractList.ListItr
9.ProductB2=LinkedList.ListItr
ArrayList和LinkedList分别是List接口的两种实现，前者是基于数组操作，后者是基于链表。两者都可以产生Iterator和ListIterator，而Iterator的实现都是在AbstractList中实现的，是一样的处理方式，而对于ListIterator的实现却不相同，AbstractList.ListItr是基于数组的操作，LinkedList.ListItr是基于链表的操作方式。
所以抽象工厂模式一般是为了处理抽象产品多于一个的问题，而且这些产品多数情况下是有关系的，像上述JAVA集合框架的例子当中，Iterator和ListIterator就是继承的关系，大部分情况下，很少会使用抽象工厂模式去创造一批毫无关系的产品。
基于抽象工厂一旦定义，抽象产品的个数就已经固定，所以最好在抽象产品的个数不太会变化的情况下使用抽象工厂模式，当然，我们可以使用继承去弥补抽象工厂模式的这一不足，创造另外一个继承体系去扩展现有的框架。
下面LZ给出简单工厂模式，工厂方法模式一直到抽象工厂模式的演变过程，三者是由简到繁的关系。由于三者都已经详细的解释过，所以此处不再多做解释，留给各位读者自己思考它们的进化过程，首先LZ给出简单工厂的具体代码。
//抽象产品
interface Product{} //具体产品
class ProductA implements Product{}
class ProductB implements Product{} //产品工厂（下一步就是它的进化，就变成了工厂方法模式）
public class ProductFactory { private ProductFactory(){} public static Product getProduct(String productName){
if (productName.equals("A")) {
return new ProductA();
}else if (productName.equals("B")) {
return new ProductB();
}else {
return null;
}
}
}
LZ在上面加了简单的注释，下面LZ给出工厂方法模式的代码，注意，前面有关产品的类和接口是不变的。
//抽象产品
interface Product{} //具体产品
class ProductA implements Product{}
class ProductB implements Product{} //将简单工厂中的工厂给抽象成接口
interface Factory{
Product getProduct();
}
//具体的工厂A，创造产品A
class FactoryA implements Factory{ public Product getProduct() {
return new ProductA();
} }
//具体的工厂B，创造产品B
class FactoryB implements Factory{ public Product getProduct() {
return new ProductB();
} }
可以看到，产品部分并没有变化，只是将简单工厂中的工厂类抽象成接口，并给相应产品添加相应的工厂类，就进化成了工厂方法模式。下面我们再看工厂方法如何进化成抽象工厂模式。
//抽象产品
interface Product{} //具体产品
class ProductA implements Product{}
class ProductB implements Product{} //多了一个抽象产品1
interface Product1{} //具体产品1
class Product1A implements Product1{}
class Product1B implements Product1{} //原有的工厂方法模式的工厂里添加一个方法
interface Factory{
Product getProduct();
//添加另外一个产品族的创造方法
Product1 getProduct1();
}
//具体的工厂A，创造产品A
class FactoryA implements Factory{ public Product getProduct() {
return new ProductA();
}
//添加相应的实现
public Product1 getProduct1() {
return new Product1A();
} }
//具体的工厂B，创造产品B
class FactoryB implements Factory{ public Product getProduct() {
return new ProductB();
}
//添加相应的实现
public Product1 getProduct1() {
return new Product1B();
} }
与工厂方法对比下就发现，多了一个产品系列叫Product1，工厂接口里多了一个方法，叫getProduct1，所以抽象工厂模式就是工厂方法模式添加了抽象产品所演变而来的。
