设计模式之抽象工厂模式

抽象工厂模式解释：

抽象工厂模式是所有形态的工厂模式中最为抽象和最其一般性的。抽象工厂模式可以向客户端提供一个接口，使得客户端在不必指定产品的具体类型的情况下，能够创建多个产品族的产品对象。

模式中包含的角色及其职责：
1、抽象工厂（Creator）角色
抽象工厂模式的核心，包含对多个产品结构的声明，任何工厂类都必须实现这个接口。

2、具体工厂（ Concrete Creator）角色
具体工厂类是抽象工厂的一个实现，负责实例化某个产品族中的产品对象。

3、抽象（Product）角色
抽象模式所创建的所有对象的父类，它负责描述所有实例所共有的公共接口。

4、具体产品（Concrete Product）角色
抽象模式所创建的具体实例对象

通俗解释：
抽象工厂模式，就好比是两个工厂方法模式的叠加。抽象工厂创建的是一系列相关的对象，其中创建的实现其实就是采用的工厂方法模式。
在工厂Factory中的每一个方法，就好比是一条生产线，而生产线实际需要生产什么样的产品，这是由Factory1和Factory2去决定的，这样便延迟了具体子类的实例化；
同时集中化了生产线的管理，节省了资源的浪费。

抽象基类：
1）AbstractProductA、AbstractProductB：分别代表两种不同类型的产品，由具体的产品派生类对其实现
2）AbstractFactory：抽象工厂类，提供创建两种产品的接口CreateProductA和CreateProductB，由派生的各个具体工厂类对其实现
说明：
AbstractFactory模式关键就是将这一组对象的创建封装到一个用于创建对象的类（ConcreteFactory）中
Abstract Factory模式和Factory最大的差别
就是抽象工厂创建的是一系列相关的对象,其中创建的实现其实采用的就是Factory模式的方法,对于某个实现的有一个派生出来的抽象工厂,另一个实现有另一个派生出来的工厂
抽象工厂需要特别注意的地方就是区分不同类型的产品和这些产品的不同实现.显而易见的,如果有n种产品同时有m中不同的实现,那么根据乘法原理可知有n*m个Factory模式的使用
AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。
并且可以看到，AbstractFactory模式通常都是使用Factory模式实现（ConcreteFactory1）。

#include <iostream>
using namespace std;

class Fruit
{
public:
    virtual void SayName() = 0;
};

class AbstractFactory
{
public:
    virtual Fruit* CreateBanana() = 0;
    virtual Fruit* CreateApple() = 0;
};

class NorthBanana : public Fruit
{
public:
    virtual void SayName()
    {
        cout << "我是北方香蕉" << endl;
    }
};

class NorthApple : public Fruit
{
public:
    virtual void SayName()
    {
        cout << "我是北方苹果" << endl;
    }
};


class SourthBanana : public Fruit
{
public:
    virtual void SayName()
    {
        cout << "我是南方香蕉" << endl;
    }
};


class SourthApple : public Fruit
{
public:
    virtual void SayName()
    {
        cout << "我是南方苹果" << endl;
    }
};

class NorthFacorty : public AbstractFactory
{
    virtual Fruit * CreateBanana()
    {
        return new NorthBanana;
    }
    virtual Fruit * CreateApple()
    {
        return new NorthApple;
    }
};

class SourthFacorty : public AbstractFactory
{
    virtual Fruit * CreateBanana()
    {
        return new SourthBanana;
    }
    virtual Fruit * CreateApple()
    {
        return new SourthApple;
    }
};


void main()
{
    Fruit            *fruit = NULL;
    AbstractFactory *af = NULL;

    ///--------------
    af = new SourthFacorty;
    fruit = af->CreateApple();
    fruit->SayName();
    delete fruit;
    fruit = af->CreateBanana();
    fruit->SayName();
    delete fruit;

    ///------
    af = new NorthFacorty;
    fruit = af->CreateApple();
    fruit->SayName();
    delete fruit;
    fruit = af->CreateBanana();
    fruit->SayName();
    delete fruit;

    delete af;
    system("pause");
    return ;
}

“开放-封闭”原则：

抽象工厂可以很好的应对增加新产品族的问题（即a4/b4/c4），且符合“开放-封闭”原则，但是若是增加新的产品结构的话（即d/d1/d2），就是说a/b/c/d这4中方法必须同时使用了，那就必须修改工厂角色。不符合“开放-封闭”原则。综合来讲，抽象工厂模式以一种倾斜的方式支持增加新的产品，它为新产品族的增加提供方便，而不能为新的产品结构的增加提供这样的方便。

实现要点：

* 在抽象工厂模式中，选用哪种产品族的问题，需要采用工厂方法或简单工厂模式来配合解决。
* 抽象工厂模式和工厂方法模式一样，都把对象的创建延迟到了他的子类中。
* 具体的工厂类可以设计成单例类，他只向外界提供自己唯一的实例。

与其他工厂模式的联系和异同：

* 抽象工厂模式中的具体工厂负责生产一个产品族的产品。而产品族的增加只需要增加与其对应的具体工厂。
* 3种工厂模式都是创建型模式，都是创建对象的，但都把产品具体创建的过程给隐藏了。
* 工厂方法模式是针对一种产品结构，而抽象工厂模式是针对多种产品结构。

适用性：
在以下情况下应当考虑使用抽象工厂模式：

* 一个系统不应当依赖于产品类实例如何被创建、组合和表达的细节，这对于所有形态的工厂模式都是重要的。
* 这个系统有多于一个的产品族，而系统只消费其中某一产品族。
* 同属于同一个产品族的产品是在一起使用的，这一约束必须在系统的设计中体现出来。
* 系统提供一个产品类的库，所有的产品以同样的接口出现，从而使客户端不依赖于实现。

应用场景：

* 支持多种观感标准的用户界面工具箱（Kit）。
* 游戏开发中的多风格系列场景，比如道路，房屋，管道等。