一、 抽象工廠（Abstract Factory）模式
抽象工廠模式是所有形態(tài)的工廠模式中最為抽象和最具一般性的一種形態(tài)。
為了方便引進抽象工廠模式，引進一個新概念：產品族（Product Family）。所謂產品族，是指位于不同產品等級結構，功能相關聯(lián)的產品組成的家族。如圖：
圖中一共有四個產品族，分布于三個不同的產品等級結構中。只要指明一個產品所處的產品族以及它所屬的等級結構，就可以唯一的確定這個產品。
引進抽象工廠模式
所謂的抽象工廠是指一個工廠等級結構可以創(chuàng)建出分屬于不同產品等級結構的一個產品族中的所有對象。如果用圖來描述的話，如下圖：
二、 Abstract Factory模式的結構：
圖中描述的東西用產品族描述如下：
抽象工廠（Abstract Factory）角色：擔任這個角色的是工廠方法模式的核心，它是與應用系統(tǒng)商業(yè)邏輯無關的。
具體工廠（Concrete Factory）角色：這個角色直接在客戶端的調用下創(chuàng)建產品的實例。這個角色含有選擇合適的產品對象的邏輯，而這個邏輯是與應用系統(tǒng)的商業(yè)邏輯緊密相關的。
抽象產品（Abstract Product）角色：擔任這個角色的類是工廠方法模式所創(chuàng)建的對象的父類，或它們共同擁有的接口。
具體產品（Concrete Product）角色：抽象工廠模式所創(chuàng)建的任何產品對象都是某一個具體產品類的實例。這是客戶端最終需要的東西，其內部一定充滿了應用系統(tǒng)的商業(yè)邏輯。
三、 程序舉例：
該程序演示了抽象工廠的結構，本身不具有任何實際價值。
 // Abstract Factory pattern -- Structural example
using System;
// "AbstractFactory"
abstract class AbstractFactory
  {
// Methods
abstract public AbstractProductA CreateProductA();
abstract public AbstractProductB CreateProductB();
}
// "ConcreteFactory1"
class ConcreteFactory1 : AbstractFactory
{
// Methods
override public AbstractProductA CreateProductA()
{
return new ProductA1();
}
override public AbstractProductB CreateProductB()
{
return new ProductB1();
}
}
// "ConcreteFactory2"
class ConcreteFactory2 : AbstractFactory
{
// Methods
override public AbstractProductA CreateProductA()
{
return new ProductA2();
}
override public AbstractProductB CreateProductB()
{
return new ProductB2();
}
}
// "AbstractProductA"
abstract class AbstractProductA
{
}
// "AbstractProductB"
abstract class AbstractProductB
{
// Methods
abstract public void Interact( AbstractProductA a );
}
// "ProductA1"
class ProductA1 : AbstractProductA
{
}
// "ProductB1"
class ProductB1 : AbstractProductB
{
// Methods
override public void Interact( AbstractProductA a )
{
Console.WriteLine( this + " interacts with " + a );
}
}
// "ProductA2"
class ProductA2 : AbstractProductA
{
}
// "ProductB2"
class ProductB2 : AbstractProductB
{
// Methods
override public void Interact( AbstractProductA a )
{
Console.WriteLine( this + " interacts with " + a );
}
}
// "Client" - the interaction environment of the products
class Environment
{
// Fields
private AbstractProductA AbstractProductA;
private AbstractProductB AbstractProductB;
// Constructors
public Environment( AbstractFactory factory )
{
AbstractProductB = factory.CreateProductB();
AbstractProductA = factory.CreateProductA();
}
// Methods
public void Run()
{
AbstractProductB.Interact( AbstractProductA );
}
}
/**////
/// ClientApp test environment
/// class ClientApp
{
public static void Main(string[] args)
{
AbstractFactory factory1 = new ConcreteFactory1();
Environment e1 = new Environment( factory1 );
e1.Run();
AbstractFactory factory2 = new ConcreteFactory2();
Environment e2 = new Environment( factory2 );
e2.Run();
}
}
四、 在什么情形下使用抽象工廠模式：
在以下情況下應當考慮使用抽象工廠模式：
- 一個系統(tǒng)不應當依賴于產品類實例如何被創(chuàng)建、組合和表達的細節(jié)，這對于所有形態(tài)的工廠模式都是重要的。
- 這個系統(tǒng)有多于一個的產品族，而系統(tǒng)只消費其中某一產品族。
- 同屬于同一個產品族的產品是在一起使用的，這一約束必須在系統(tǒng)的設計中體現(xiàn)出來。
- 系統(tǒng)提供一個產品類的庫，所有的產品以同樣的接口出現(xiàn)，從而使客戶端不依賴于實現(xiàn)。
五、 抽象工廠的起源
據(jù)說最早的應用是用來創(chuàng)建在不同操作系統(tǒng)的視窗環(huán)境下都能夠運行的系統(tǒng)。比如在Windows與Unix系統(tǒng)下都有視窗環(huán)境的構件，在每一個操作系
統(tǒng)中，都有一個視窗構件組成的構件家族。我們可以通過一個抽象角色給出功能描述，而由具體子類給出不同操作系統(tǒng)下的具體實現(xiàn)，如圖：
可以發(fā)現(xiàn)上面產品類圖有兩個產品等級結構，分別是Button與Text；同時有兩個產品族：Unix產品族與Windows產品族。
系統(tǒng)對產品對象的創(chuàng)建要求由一個工廠的等級結構滿足。其中有兩個具體工廠角色，即UnixFactory和WinFactory。UnixFactory對象負責創(chuàng)建Unix產品族中的產品，而WinFactory負責創(chuàng)建Windows產品族中的產品。
顯然一個系統(tǒng)只能夠在某一個操作系統(tǒng)的視窗環(huán)境下運行，而不能同時在不同的操作系統(tǒng)上運行。所以，系統(tǒng)實際上只能消費屬于同一個產品族的產品。
在現(xiàn)代的應用中，抽象工廠模式的使用范圍已經大大擴大了，不再要求系統(tǒng)只能消費某一個產品族了。
六、 Abstract Factory模式在實際系統(tǒng)中的實現(xiàn)
Herbivore：草食動物
Carnivore：食肉動物
Bison：[‘baisn]，美洲或歐洲的野牛
下面實際代碼演示了一個電腦游戲中創(chuàng)建不同動物的抽象工廠。盡管在不同大陸下動物物種是不一樣的，但動物間的關系仍然保留了下來。
// Abstract Factory pattern -- Real World example
using System;
// "AbstractFactory"
abstract class ContinentFactory
{
// Methods
abstract public Herbivore CreateHerbivore();
abstract public Carnivore CreateCarnivore();
}
// "ConcreteFactory1"
class AfricaFactory : ContinentFactory
{
// Methods
override public Herbivore CreateHerbivore()
{ return new Wildebeest(); }
override public Carnivore CreateCarnivore()
{ return new Lion(); }
}
// "ConcreteFactory2"
class AmericaFactory : ContinentFactory
  {
 // Methods
override public Herbivore CreateHerbivore()
  { return new Bison(); }
override public Carnivore CreateCarnivore()
{ return new Wolf(); }
 }
// "AbstractProductA"
abstract class Herbivore
{
}
// "AbstractProductB"
abstract class Carnivore
{
// Methods
abstract public void Eat( Herbivore h );
}
// "ProductA1"
class Wildebeest : Herbivore
{
}
// "ProductB1"
class Lion : Carnivore
{
// Methods
override public void Eat( Herbivore h )
{
// eat wildebeest
Console.WriteLine( this + " eats " + h );
 }
}
// "ProductA2"
class Bison : Herbivore
{
}
// "ProductB2"
class Wolf : Carnivore
{
// Methods
override public void Eat( Herbivore h )
{
// Eat bison
Console.WriteLine( this + " eats " + h );
}
}
// "Client"
class AnimalWorld
{
// Fields
private Herbivore herbivore;
private Carnivore carnivore;
// Constructors
public AnimalWorld( ContinentFactory factory )
{
carnivore = factory.CreateCarnivore();
herbivore = factory.CreateHerbivore();
}
// Methods
public void RunFoodChain()
{ carnivore.Eat(herbivore); }
}
/**////
/// GameApp test class
/// class GameApp
{
public static void Main( string[] args )
{
// Create and run the Africa animal world
ContinentFactory africa = new AfricaFactory();
AnimalWorld world = new AnimalWorld( africa );
world.RunFoodChain();
// Create and run the America animal world
ContinentFactory america = new AmericaFactory();
world = new AnimalWorld( america );
world.RunFoodChain();
}
}
抽象工廠的另外一個例子：
如何設計抽象類工廠留作思考。
七、 "開放－封閉"原則
"開放－封閉"原則要求系統(tǒng)對擴展開放，對修改封閉。通過擴展達到增強其功能的目的。對于涉及到多個產品族與多個產品等級結構的系統(tǒng)，其功能增強包括兩方面：
增加產品族：Abstract Factory很好的支持了"開放－封閉"原則。
增加新產品的等級結構：需要修改所有的工廠角色，沒有很好支持"開放－封閉"原則。
綜合起來，抽象工廠模式以一種傾斜的方式支持增加新的產品，它為新產品族的增加提供方便，而不能為新的產品等級結構的增加提供這樣的方便。
|
