工厂方法模式是为了克服简单工厂模式的缺点而设计出来的,简单工厂模式的工厂类随着产品类的增加需要增加额外的代码），而工厂方法模式每个具体工厂类只完成单个实例的创建,所以它具有很好的可扩展性。。但是在现实生活中，一个工厂只创建单个产品这样的例子很少
定义：
抽象工厂（Abstract Factory）模式意图：为创建一组相关或相互依赖对象提供了一个接口，而且无需指定它们的具体类。
抽象工厂可以向客户提供一个接口，是客户可以在不必指定产品具体类型的情况下，创建多个产品家族中的产品对象，它强调的“系列对象”的变化。
参与者
抽象工厂模式参与者：
◊ AbstractFactory：声明一个创建抽象产品对象的操作接口
◊ ConcreteFactory：实现创建具体产品对象的操作
◊ AbstractProduct：声明一类产品对象接口
◊ Product
°定义一个被相应具体工厂创建的产品对象
°实现AbstractProduct接口
◊ Client：使用AbstractFactory和AbstractProduct类声明的接口
在抽象工厂模式中，产品的创建由ConcreteFactory来完成，抽象工厂模式的ConcreteFactory不是负责一种具体Product的创建，而是负责一个Product族的创建。
分析：
抽象工厂模式将具体产品的创建延迟到具体工厂的子类中，这样将对象的创建封装起来，可以减少客户端与具体产品类之间的依赖，从而使系统耦合度低，这样更有利于后期的维护和扩展
其实现要点有：
提供一系列对象的接口。问：如何去实现呢？答：提供多个产品的抽象接口
创建多个产品族中的多个产品对象。问：如何做到呢？答：每个具体工厂创建一个产品族中的多个产品对象，多个具体工厂就可以创建多个产品族中的多个对象了。
适用情况
1.系统不依赖于产品类实例如何被创建，组合和表达的细节。
2.系统的产品有多于一个的产品族，而系统只消费其中某一族的产品
3.同属于同一个产品族是在一起使用的。这一约束必须在系统的设计中体现出来。
4.系统提供一个产品类的库，所有产品以同样的接口出现，从而使客户端不依赖于实现。
特点
◊ 隔离了具体类的生成，客户不需要知道怎样生成每一个具体Product，什么时间生成的。它将客户与具体的类分离，依赖于抽象类，耦合性低。
◊ 一个产品族中的多个对象设计成一起工作，它能保证客户端始终只使用一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说是非常实用的一种设计模式。
◊ 有利于更换产品系列，由于客户端只依赖于抽象类，更换产品系列时，只需要更改一下具体工厂名就可以。
◊ 难以支持新种类的产品，这是因为抽象工厂接口确定了可以被创建的产品集合，支持新种类的产品就需要扩展该工厂接口，这将引起抽象工厂类及其所有子类的改变。
优点：
1.它分离了具体的类
2.它使得易于交换产品系列
3.它有利于产品的一致性
缺点：
难以支持新种类的产品
抽象工厂模式与工厂方法模式区别
◊ 工厂方法模式只有一个抽象产品类，而抽象工厂模式可以有多个抽象产品类。
◊ 工厂方法模式针对一个产品等级结构，可以派生出多个具体产品类；抽象工厂模式针对面向多个产品等级结构，每个抽象产品类可以派生出多个具体产品类。
/// <summary>
/// 下面以绝味鸭脖连锁店为例子演示下抽象工厂模式
/// 因为每个地方的喜欢的口味不一样，有些地方喜欢辣点的，有些地方喜欢吃不辣点
/// 客户端调用
/// </summary>
class Client
{
static void Main(string[] args)
{
// 南昌工厂制作南昌的鸭脖和鸭架
AbstractFactory nanChangFactory = new NanChangFactory();
YaBo nanChangYabo = nanChangFactory.CreateYaBo();
nanChangYabo.Print();
YaJia nanChangYajia= nanChangFactory.CreateYaJia();
nanChangYajia.Print();
// 上海工厂制作上海的鸭脖和鸭架
AbstractFactory shangHaiFactory = new ShangHaiFactory();
shangHaiFactory.CreateYaBo().Print();
shangHaiFactory.CreateYaJia().Print();
Console.Read();
}
}
/// <summary>
/// 抽象工厂类，提供创建两个不同地方的鸭架和鸭脖的接口
/// </summary>
public abstract class AbstractFactory
{
// 抽象工厂提供创建一系列产品的接口，这里作为例子，只给出了绝味中鸭脖和鸭架的创建接口
public abstract YaBo CreateYaBo();
public abstract YaJia CreateYaJia();
}
/// <summary>
/// 南昌绝味工厂负责制作南昌的鸭脖和鸭架
/// </summary>
public class NanChangFactory : AbstractFactory
{
// 制作南昌鸭脖
public override YaBo CreateYaBo()
{
return new NanChangYaBo();
}
// 制作南昌鸭架
public override YaJia CreateYaJia()
{
return new NanChangYaJia();
}
}
/// <summary>
/// 上海绝味工厂负责制作上海的鸭脖和鸭架
/// </summary>
public class ShangHaiFactory : AbstractFactory
{
// 制作上海鸭脖
public override YaBo CreateYaBo()
{
return new ShangHaiYaBo();
}
// 制作上海鸭架
public override YaJia CreateYaJia()
{
return new ShangHaiYaJia();
}
}
/// <summary>
/// 鸭脖抽象类，供每个地方的鸭脖类继承
/// </summary>
public abstract class YaBo
{
/// <summary>
/// 打印方法，用于输出信息
/// </summary>
public abstract void Print();
}
/// <summary>
/// 鸭架抽象类，供每个地方的鸭架类继承
/// </summary>
public abstract class YaJia
{
/// <summary>
/// 打印方法，用于输出信息
/// </summary>
public abstract void Print();
}
/// <summary>
/// 南昌的鸭脖类，因为江西人喜欢吃辣的，所以南昌的鸭脖稍微会比上海做的辣
/// </summary>
public class NanChangYaBo : YaBo
{
public override void Print()
{
Console.WriteLine("南昌的鸭脖");
}
}
/// <summary>
/// 上海的鸭脖没有南昌的鸭脖做的辣
/// </summary>
public class ShangHaiYaBo : YaBo
{
public override void Print()
{
Console.WriteLine("上海的鸭脖");
}
}
/// <summary>
/// 南昌的鸭架
/// </summary>
public class NanChangYaJia : YaJia
{
public override void Print()
{
Console.WriteLine("南昌的鸭架子");
}
}
/// <summary>
/// 上海的鸭架
/// </summary>
public class ShangHaiYaJia : YaJia
{
public override void Print()
{
Console.WriteLine("上海的鸭架子");
}
}抽象工厂的分析
抽象工厂模式很难支持新种类产品的变化。这是因为抽象工厂接口中已经确定了可以被创建的产品集合，如果需要添加新产品，此时就必须去修改抽象工厂的接口，这样就涉及到抽象工厂类的以及所有子类的改变，这样也就违背了“开发——封闭”原则。
.NET中抽象工厂模式实现
抽象工厂模式在实际中的应用也是相当频繁的，然而在我们.NET类库中也存在应用抽象工厂模式的类，这个类就是System.Data.Common.DbProviderFactory，这个类位于System.Data.dll程序集中,该类扮演抽象工厂模式中抽象工厂的角色，我们可以用reflector反编译工具查看该类的实现：
/// 扮演抽象工厂的角色
/// 创建连接数据库时所需要的对象集合，
/// 这个对象集合包括有 DbConnection对象（这个是抽象产品类,如绝味例子中的YaBo类）、DbCommand类、DbDataAdapter类，针对不同的具体工厂都需要实现该抽象类中方法，
public abstract class DbProviderFactory
{
// 提供了创建具体产品的接口方法
protected DbProviderFactory();
public virtual DbCommand CreateCommand();
public virtual DbCommandBuilder CreateCommandBuilder();
public virtual DbConnection CreateConnection();
public virtual DbConnectionStringBuilder CreateConnectionStringBuilder();
public virtual DbDataAdapter CreateDataAdapter();
public virtual DbDataSourceEnumerator CreateDataSourceEnumerator();
public virtual DbParameter CreateParameter();
public virtual CodeAccessPermission CreatePermission(PermissionState state);
}DbProviderFactory类是一个抽象工厂类，该类提供了创建数据库连接时所需要的对象集合的接口，实际创建的工作在其子类工厂中进行，微软使用的是SQL Server数据库，因此提供了连接SQL Server数据的具体工厂实现，具体代码可以用反编译工具查看，具体代码如下：
/// 扮演着具体工厂的角色，用来创建连接SQL Server数据所需要的对象
public sealed class SqlClientFactory : DbProviderFactory, IServiceProvider
{
// Fields
public static readonly SqlClientFactory Instance = new SqlClientFactory();
// 构造函数
private SqlClientFactory()
{
}
// 重写抽象工厂中的方法
public override DbCommand CreateCommand()
{ // 创建具体产品
return new SqlCommand();
}
public override DbCommandBuilder CreateCommandBuilder()
{
return new SqlCommandBuilder();
}
public override DbConnection CreateConnection()
{
return new SqlConnection();
}
public override DbConnectionStringBuilder CreateConnectionStringBuilder()
{
return new SqlConnectionStringBuilder();
}
public override DbDataAdapter CreateDataAdapter()
{
return new SqlDataAdapter();
}
public override DbDataSourceEnumerator CreateDataSourceEnumerator()
{
return SqlDataSourceEnumerator.Instance;
}
public override DbParameter CreateParameter()
{
return new SqlParameter();
}
public override CodeAccessPermission CreatePermission(PermissionState state)
{
return new SqlClientPermission(state);
}
}java
工厂方法模式与抽象工厂模式对比：
工厂方法模式 抽象工厂模式
针对的是一个产品等级结构 针对的是面向多个产品等级结构
一个抽象产品类 多个抽象产品类
可以派生出多个具体产品类 每个抽象产品类可以派生出多个具体产品类
一个抽象工厂类，可以派生出多个具体工厂类 一个抽象工厂类，可以派生出多个具体工厂类
每个具体工厂类只能创建一个具体产品类的实例 每个具体工厂类可以创建多个具体产品类的实例
水果抽象接口：
package com.design.abstractfactory;
public interface Fruit {
void fruitInfo();
}蔬菜抽象接口：
package com.design.abstractfactory;
public interface Vegetable {
void vegetableInfo();
}
工厂抽象接口：
package com.design.abstractfactory;
public interface Factory {
Fruit createFruit();
Vegetable createVegetable();
}具体类：北方水果
package com.design.abstractfactory;
public class NorthFruit implements Fruit {
@Override
public void fruitInfo() {
System.out.println("North-Apple");
}
}具体类：南方水果
package com.design.abstractfactory;
public class SouthFruit implements Fruit {
@Override
public void fruitInfo() {
System.out.println("South-Banana");
}
}具体类：北方蔬菜
package com.design.abstractfactory;
public class NorthVegetable implements Vegetable {
@Override
public void vegetableInfo() {
System.out.println("North-Tomato");
}
}具体类：南方蔬菜
package com.design.abstractfactory;
public class SouthVegetable implements Vegetable {
@Override
public void vegetableInfo() {
System.out.println("South-Taro");
}
}具体类：北方产品工厂
package com.design.abstractfactory;
public class NorthProductFactory implements Factory {
@Override
public Fruit createFruit() {
return new NorthFruit();
}
@Override
public Vegetable createVegetable() {
return new NorthVegetable();
}
}具体类：南方产品工厂
package com.design.abstractfactory;
public class SouthProductFactory implements Factory {
@Override
public Fruit createFruit() {
return new SouthFruit();
}
@Override
public Vegetable createVegetable() {
return new SouthVegetable();
}
}测试类：
package com.design.abstractfactory;
public class Client {
public static void main(String[] args){
Factory northFactory = new NorthProductFactory();
Factory southFactory = new SouthProductFactory();
System.out.println("北方产品：");
northFactory.createFruit().fruitInfo();
northFactory.createVegetable().vegetableInfo();
System.out.println("南方产品：");
southFactory.createFruit().fruitInfo();
southFactory.createVegetable().vegetableInfo();
}
}
输出：
个人总结：
创建多个的抽象产品对象，对应对个系列一个抽象工厂类，定义可创建抽象产品系列，具体工厂类实现抽象工厂类
扩展知识：
扩展知识：
(1) 产品等级结构：产品等级结构即产品的继承结构，如一个抽象类是电视机，其子类有海尔电视机、海信电视机、TCL电视机，则抽象电视机与具体品牌的电视机之间构成了一个产品等级结构，抽象电视机是父类，而具体品牌的电视机是其子类。
(2) 产品族：在抽象工厂模式中，产品族是指由同一个工厂生产的，位于不同产品等级结构中的一组产品，如海尔电器工厂生产的海尔电视机、海尔电冰箱，海尔电视机位于电视机产品等级结构中，海尔电冰箱位于电冰箱产品等级结构中，海尔电视机、海尔电冰箱构成了一个产品族。
抽象工厂模式是所有形式的工厂模式中最为抽象和最具一般性的一种形式。
每一个具体工厂可以生产属于一个产品族的所有产品，
当一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象时，抽象工厂模式比工厂方法模式更为简单、更有效率。
参考文献：
http://www.cnblogs.com/zhili/p/AbstractFactory.html
https://www.cnblogs.com/libingql/archive/2012/12/09/2809754.html