設計模式之 abstractfactory

常見設計模式的解析和實現(C++)之二-Abstract Factory模式

作用:
提供一個創建一系列相關或相互依賴對象的接口，而無需指定它們具體的類。

UML結構圖:


抽象基類:
1)ProductA,ProductB:分別代表不同類型的產品,而它們的派生類則是這種產品的一個實現.
2)AbstractFactory:生產這一系列產品的一個抽象工廠,它的派生類是不同的實現.

接口函數:
1)AbstractFactory::CreateProductA和AbstractFactory::CreateProductB:分別是生產不同產品的不同的實現,由各個派生出來的抽象工廠實現之.

解析:
Abstract Factory模式和Factory最大的差別就是抽象工廠創建的是一系列相關的對象,其中創建的實現其實採用的就是Factory模式的方法,對於某個實現的有一個派生出來的抽象工廠,另一個實現有另一個派生出來的工廠,等等.

可以舉一個簡單的例子來解釋這個模式:比如,同樣是雞腿(ProductA)和漢堡(ProductB),它們都可以有商店出售(AbstractFactory),但是有不同的實現,有肯德基(ConcreateFactory1)和麥當勞(ConcreateFactory2)兩家生產出來的不同風味的雞腿和漢堡(也就是ProductA和ProductB的不同實現).
而負責生產漢堡和雞腿的就是之前提過的Factory模式了.

抽象工廠需要特別注意的地方就是區分不同類型的產品和這些產品的不同實現.顯而易見的,如果有n種產品同時有m中不同的實現,那麼根據乘法原理可知有n*m個Factory模式的使用.


實現:
1)AbstractFactory.h

/**//********************************************************************
    created:    2006/07/19
    filename:     AbstractFactory.h
    author:        李創
                http://www.cppblog.com/converse/

    purpose:    AbstractFactory的演示代碼
*********************************************************************/

#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

2)AbstractFactory.cpp

/**//********************************************************************
    created:    2006/07/19
    filename:     AbstractFactory.cpp
    author:        李創
                http://www.cppblog.com/converse/

    purpose:    AbstractFactory的演示代碼
*********************************************************************/

#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();
}

3)Main.cpp(測試代碼)

/**//********************************************************************
    created:    2006/07/19
    filename:     Main.cpp
    author:        李創
                http://www.cppblog.com/converse/

    purpose:    AbstractFactory的測試代碼
*********************************************************************/

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

int main()
{
    // 生產產品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;
}