1. 适用性
在以下情况可以使用AbstractFactory模式
• 一个系统要独立于它的产品的创建、组合和表示时。
• 一个系统要由多个产品系列中的一个来配置时。
• 当你要强调一系列相关的产品对象的设计以便进行联合使用时。
• 当你提供一个产品类库，而只想显示它们的接口而不是实现时。
2. 参与者
• A b s t r a c t Fa c t o r y
— 声明一个创建抽象产品对象的操作接口。
• C o n c r e t e Fa c t o r y
— 实现创建具体产品对象的操作。
• A b s t r a c t Pr o d u c t
— 为一类产品对象声明一个接口。
• C o n c r e t e Pr o d u c t
— 定义一个将被相应的具体工厂创建的产品对象。
— 实现A b s t r a c t P r o d u c t接口。
• C l i e n t
— 仅使用由A b s t r a c t F a c t o r y和A b s t r a c t P r o d u c t类声明的接口。
3. 协作
• 通常在运行时刻创建一个C o n c r e t e F a c t r o y类的实例。这一具体的工厂创建具有特定实现
的产品对象。为创建不同的产品对象，客户应使用不同的具体工厂。
• AbstractFactory将产品对象的创建延迟到它的C o n c r e t e F a c t o r y子类。
8. 效果
A b st r a c t F a c t o r y模式有下面的一些优点和缺点：
1) 它分离了具体的类 Abstract Factory模式帮助你控制一个应用创建的对象的类。因为一个工厂封装创建产品对象的责任和过程，它将客户与类的实现分离。客户通过它们的抽象接口操纵实例。产品的类名也在具体工厂的实现中被分离；它们不出现在客户代码中。
2) 它使得易于交换产品系列 一个具体工厂类在一个应用中仅出现一次—即在它初始化的时候。这使得改变一个应用的具体工厂变得很容易。它只需改变具体的工厂即可使用不同的产品配置，这是因为一个抽象工厂创建了一个完整的产品系列，所以整个产品系列会立刻改变
3) 它有利于产品的一致性 当一个系列中的产品对象被设计成一起工作时，一个应用一次只能使用同一个系列中的对象，这一点很重要。而A b s t r a c t F a c t o r y很容易实现这一点。
4) 难以支持新种类的产品 难以扩展抽象工厂以生产新种类的产品。这是因为A b s t r a c t F a c t o r y接口确定了可以被创建的产品集合。支持新种类的产品就需要扩展该工厂接口，这将涉及A b s t r a c t F a c t o r y类及其所有子类的改变。我们会在实现一节讨论这个问题的一个解决
办法。
下面是用C#语言简单的实现：
类图：
AbstractFactory等类的源码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AbstractFactory
{
//申明抽象的产品类A
abstract class AbstractProductA
{
abstract public void RightProduct();
}
//AbstractProductA 的具体的子类
class ProductA1 : AbstractProductA
{
public override void RightProduct()
{
Console.WriteLine("This is the real Product ProductA One! "+this.GetType().ToString());
}
}
class ProductA2 : AbstractProductA
{
public override void RightProduct()
{
Console.WriteLine("This is the real Product ProductA Two! "+this.GetType().ToString());
}
}
//申明抽象的产品类B
abstract class AbstractProductB
{
abstract public void RightProduct();
}
//AbstractProductB 的具体的子类
class ProductB1 : AbstractProductB
{
public override void RightProduct()
{
Console.WriteLine("This is the real Product ProductB One! " + this.GetType().ToString());
}
}
class ProductB2 : AbstractProductB
{
public override void RightProduct()
{
Console.WriteLine("This is the real Product ProductB Two! " + this.GetType().ToString());
}
}
//抽象工厂
abstract class MyAbstractFactory
{
abstract public AbstractProductA CreatProductA();
abstract public AbstractProductB CreatProductB();
}
//抽象工厂的子类，主要是某类产品的工厂
class ConcreteFactory1 : MyAbstractFactory
{
public override AbstractProductA CreatProductA()
{
return new ProductA1();
}
public override AbstractProductB CreatProductB()
{
return new ProductB1();
}
}
class ConcreteFactory2 : MyAbstractFactory
{
public override AbstractProductA CreatProductA()
{
return new ProductA2();
}
public override AbstractProductB CreatProductB()
{
return new ProductB2();
}
}
}
主程序源码：
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using System.Threading.Tasks;
namespace AbstractFactory
{
class Program
{
static void Main(string[] args)
{
MyAbstractFactory Factory1 = new ConcreteFactory1();
MyAbstractFactory Factory2 = new ConcreteFactory2();
AbstractProductA AProductA1 = Factory1.CreatProductA();
AbstractProductA AProductA2 = Factory2.CreatProductA();
AbstractProductB AProductB1 = Factory1.CreatProductB();
AbstractProductB AProductB2 = Factory2.CreatProductB();
AProductA1.RightProduct();
AProductA2.RightProduct();
AProductB1.RightProduct();
AProductB2.RightProduct();
Console.ReadKey();
}
}
}
运行截图：
最后是直观的关系图：