抽象工厂模式(Abstract Factory)

一、抽象工厂(Abstract Factou)模式

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定他们具体的类。是所有形态的工厂模式中最为抽象和最具一般性的一种形态。

为了方便引进抽象工厂模式，引进一个新概念：产品族（Product Family）。所谓产品族，是指位于不同产品等级结构，功能相关联的产品组成的家族。如图：

 

图中一共有四个产品族，分布于三个不同的产品等级结构中。只要指明一个产品所处的产品族以及它所属的等级结构，就可以唯一的确定这个产品。

引进抽象工厂模式

所谓的抽象工厂是指一个工厂等级结构可以创建出分属于不同产品等级结构的一个产品族中的所有对象。如果用图来描述的话，如下图：

 

 

Abstract Factory模式的结构：

图中描述的东西用产品族描述如下：

 

抽象工厂（Abstract Factory）角色：担任这个角色的是工厂方法模式的核心，它是与应用系统商业逻辑无关的。

具体工厂（Concrete Factory）角色：这个角色直接在客户端的调用下创建产品的实例。它含有选择合适产品对象的逻辑，而这个逻辑是与应用系统的商业逻辑紧密相关的。

抽象产品（Abstract Product）角色：担任这个角色的类是工厂方法模式所创建对象的父类，或它们共同拥有的接口。

具体产品（Concrete Product）角色：抽象工厂所创建的任何产品对象都是某一具体产品类的实例。这是客户端最终需要的东西，其内部一定充满了应用系统的商业逻辑。

 例子：

Abstract Factory

public abstract class AbstractFactory{
    public abstract AbstractProductA CreateProductA();
    public abstract AbstractProductB CreateProductB();
}

Concrete Factory

public class ConcreteFactory1:AbstractFactory{
    public override AbstractProductA CreateProductA()
    {   
        return new ProdutcA1();
    }
    public override AbstractProductB CreateProductB()
    {
        return new ProdutcB1();
    }

public class ConcreteFactory2:AbstractFactory{
    public override AbstractProductA CreateProductA()
    {   
        return new ProdutcA2();
    }
    public override AbstractProductB CreateProductB()
    {
        return new ProdutcB2();
    }

 

Abstract Product

public abstract class AbstractProductA
{
    public abstract OpenProduct();
}

public abstract class AbstractProductB
{
    public abstract CloseProduct();
}

 

Concrete Product

public class ProductA1:AbstractProductA
{
    public override OpenProduct()
    {
        Console.WriteLine("ProductA1 is opened");        
    }
}

public class ProductA2:AbstractProductA
{
    public override OpenProduct()
    {
        Console.WriteLine("ProductA2 is opened");        
    }
}

public class ProductB1:AbstractProductB
{
    public override CloseProduct()
    {
        Console.WriteLine("ProductB1 is closed");        
    }
}

public class ProductB2:AbstractProductB
{
    public override CloseProduct()
    {
        Console.WriteLine("ProductB2 is closed");        
    }
}

public static void main()
{    
    AbstractFactory factory1=new ConcreteFactory1();
    AbstractProductA productA1=factory1.CreateProductA();
    AbstractProductA productB1=factory1.CreateProductB();
    productA1.OpenProduct();
    productB1.CloseProduct();

    AbstractFactory factory2=new ConcreteFactory2();
    AbstractProductA productA2=factory2.CreateProductA();
    AbstractProductA productB2=factory2.CreateProductB();
    productA2.OpenProduct();
    productB2.CloseProduct();
}

运行结果：

ProductA1 is opened

ProductB1 is closed

ProductA2 is opened

ProductB2 is closed

 

在上例中，建立了2个工厂，工厂1生产A1,、B1，工厂2生产A2,、B2，如果要想加入工厂3，生产A3、B3，只需要建立实例工厂3，让它继承抽象工厂，这样就实现了系统的扩展，而无须去更改现有的系统结构。