（创建型模式）Abstract Factory——抽象工厂模式

一、意图

抽象工厂模式：提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类。

二、核心思想

    

三、优缺点分析

GOOD：

（1）最大的好处是易于交换产品系列，由于具体工厂类在一个应用中只需要初始化的时候出现一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。如ACCESS->SQL SERVER；

（2）第二大好处是：它让具体的创建实例过程与客户端分离，客户端是通过它们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现在客户代码中。如客户端只知道使用IUser和IDepartment,至于它是用SQL Server还是Access来实现就不知道了。

BAD:

当需要增加功能时，就需要增加很多类

四、标准UML图

抽象基类：

1）ProductA,ProductB：分别代表不同类型的产品，而它们的派生类则是这种产品的一个实现。

2）AbstractFactory：生产这一系列产品的一个抽象工厂，它的派生类是不同的实现。

接口函数：

AbstractFactory::CreateProductA和AbstractFactory::CreateProductB：分别是生产不同产品的不同实现，由各个派生出来的抽象工厂实现之。

解析：

Abstract Factory模式和Factory最大的差别是抽象工厂创建的是一系列相关的对象，其中创建的实现其实采用的就是Factory模式的方法，对于某个实现的有一个派生出来的抽象工厂，另一个实现有另一个派生出来的工厂。

需要特别注意的是区分不同类型的产品和这些产品的不同实现，如果有n种产品同时有m种不同的实现，那么根据乘法原理可知有n*m个简单工厂模式在运用。

五、标准源码

/************************************************************************
 * FileName    : AbstractFactory.h
 * Author      : steven oyj (steven.oyj@gmail.com)
 * Description : AbstractFactory的演示代码
 * Time        : 2010/5/18
 ************************************************************************/
#ifndef ABSTRACTFACTORY_H
#define ABSTRACTFACTORY_H

// 抽象基类AbstractProductA,代表产品A的抽象
class AbstractProductA
{
public:
    AbstractProductA() {}
    virtual ~AbstractProductA(){};
};

// 派生类ConcreateProductA1,继承自AbstractProductA,代表产品A的第一种实现
class ConcreateProductA1
    : public AbstractProductA
{
public:
    ConcreateProductA1();
    virtual ~ConcreateProductA1();
};

// 派生类ConcreateProductA2,继承自AbstractProductA,代表产品A的第二种实现
class ConcreateProductA2
    : public AbstractProductA
{
public:
    ConcreateProductA2();
    virtual ~ConcreateProductA2();
};

// 抽象基类AbstractProductB,代表产品B的抽象
class AbstractProductB
{
public:
    AbstractProductB() {}
    virtual ~AbstractProductB(){};
};

// 派生类ConcreateProductB1,继承自AbstractProductB,代表产品B的第一种实现
class ConcreateProductB1
    : public AbstractProductB
{
public:
    ConcreateProductB1();
    virtual ~ConcreateProductB1();
};

// 派生类ConcreateProductB2,继承自AbstractProductB,代表产品B的第二种实现
class ConcreateProductB2
    : public AbstractProductB
{
public:
    ConcreateProductB2();
    virtual ~ConcreateProductB2();
};

// 抽象基类AbstractFactory,工厂的抽象类,生产产品A和产品B
class AbstractFactory
{
public:
    AbstractFactory(){}
    virtual ~AbstractFactory(){}

    virtual AbstractProductA* CreateProductA() = 0;
    virtual AbstractProductB* CreateProductB() = 0;
};

// 派生类ConcreateFactory1,继承自AbstractFactory
// 生产产品A和产品B的第一种实现
class ConcreateFactory1
    : public AbstractFactory
{
public:
    ConcreateFactory1();
    virtual ~ConcreateFactory1();

    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

// 派生类ConcreateFactory2,继承自AbstractFactory
// 生产产品A和产品B的第二种实现
class ConcreateFactory2
    : public AbstractFactory
{
public:
    ConcreateFactory2();
    virtual ~ConcreateFactory2();

    virtual AbstractProductA* CreateProductA();
    virtual AbstractProductB* CreateProductB();
};

#endif

#include <iostream>
#include "AbstractFactory.h"

ConcreateProductA1::ConcreateProductA1()
{
    std::cout << "construction of ConcreateProductA1\n";
}

ConcreateProductA1::~ConcreateProductA1()
{
    std::cout << "destruction of ConcreateProductA1\n";
}

ConcreateProductA2::ConcreateProductA2()
{
    std::cout << "construction of ConcreateProductA2\n";
}

ConcreateProductA2::~ConcreateProductA2()
{
    std::cout << "destruction of ConcreateProductA2\n";
}

ConcreateProductB1::ConcreateProductB1()
{
    std::cout << "construction of ConcreateProductB1\n";
}

ConcreateProductB1::~ConcreateProductB1()
{
    std::cout << "destruction of ConcreateProductB1\n";
}

ConcreateProductB2::ConcreateProductB2()
{
    std::cout << "construction of ConcreateProductB2\n";
}

ConcreateProductB2::~ConcreateProductB2()
{
    std::cout << "destruction of ConcreateProductB2\n";
}

ConcreateFactory1::ConcreateFactory1()
{
    std::cout << "construction of ConcreateFactory1\n";
}

ConcreateFactory1::~ConcreateFactory1()
{
    std::cout << "destruction of ConcreateFactory1\n";
}

AbstractProductA* ConcreateFactory1::CreateProductA()
{
    return new ConcreateProductA1();
}

AbstractProductB* ConcreateFactory1::CreateProductB()
{
    return new ConcreateProductB1();
}

ConcreateFactory2::ConcreateFactory2()
{
    std::cout << "construction of ConcreateFactory2\n";
}

ConcreateFactory2::~ConcreateFactory2()
{
    std::cout << "destruction of ConcreateFactory2\n";
}

AbstractProductA* ConcreateFactory2::CreateProductA()
{
    return new ConcreateProductA2();
}

AbstractProductB* ConcreateFactory2::CreateProductB()
{
    return new ConcreateProductB2();
}

#include "AbstractFactory.h"
#include <stdlib.h>
#include <stdio.h>

int main()
{
    printf("%d\n",sizeof(long));
    // 生产产品A的第一种实现
    ConcreateFactory1 *pFactory1 = new ConcreateFactory1;
    AbstractProductA *pProductA = pFactory1->CreateProductA();

    // 生产产品B的第二种实现
    ConcreateFactory2 *pFactory2 = new ConcreateFactory2;
    AbstractProductB *pProductB = pFactory2->CreateProductB();

    delete pFactory1;
    delete pProductA;
    delete pFactory2;
    delete pProductB;

    system("pause");

    return 0;
}