Chapter15 抽象工厂模式

抽象工厂模式简介

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

优点：

1.易于变换产品系列，由于具体工厂类，在一个应用中只需要初始化一次，这就使得改变一个应用的具体工厂变得非常容易，它只需要改变具体工厂即可使用不同的产品配置。

2.它让具体的创建实例过程与客户端分离，客户端是通过他们的抽象接口操纵实例，产品的具体类名也被具体工厂的实现分离，不会出现客户代码中。

缺点：

当需要添加一个产品时（对照下面的UML图），如何ProductC，那么就需要添加AbstactProductC，ProductC和修改AbstractFactory、ConcreteFactory1和ConcreteFactory2,修改量太大。

抽象工厂模式UML类图

 

 AbstractProductA和AbstractProductB是两个抽象产品，之所以为抽象，是因为它们都有可能有两个不同的实现，而ProductA1、ProductA2和ProductB1、ProductB2就是对两个抽象产品的具体分类的实现。

IFactory是一个抽象工厂接口，它里面应该包含所有的产品创建的抽象方法。而ConcreteFactory1和ConcreteFactory2就是具体的工厂。

通常在运行时刻在创建一个ConcreteFactory类的实例，这个具体的工厂再创建具有特定实现的产品对象，也就是说，为创建不同的产品对象，客户端应使用不同的具体工厂。

C++代码实现

// AbstractProductA类
#ifndef _ABSTRACTPRODUCTA_HPP
#define _ABSTRACTPRODUCTA_HPP

class AbstractProductA{
public:
    virtual void displayA() = 0;
};

#endif

// AbstractProductB类
#ifndef _ABSTRACTPRODUCTB_HPP
#define _ABSTRACTPRODUCTB_HPP

class AbstractProductB{
public:
    virtual void displayB() = 0;

};

#endif

//ProductA1类
#ifndef _PRODUCTA1_HPP
#define _PRODUCTA1_HPP

#include<iostream>
#include"abstractproducta.hpp"

using namespace std;

class ProductA1 : public AbstractProductA {
public:
    virtual void displayA() override {
        cout << "ProductA1.displayA() is called" << endl;
    }
};

#endif

//ProductA2类
#ifndef _PRODUCTA2_HPP
#define _PRODUCTA2_HPP

#include<iostream>
#include"abstractproducta.hpp"

using namespace std;

class ProductA2 : public AbstractProductA {
public:
    virtual void displayA() override {
        cout << "ProductA2.displayA() is called" << endl;
    }
};

#endif

//AbstractProductB类
#ifndef _ABSTRACTPRODUCTB_HPP
#define _ABSTRACTPRODUCTB_HPP

class AbstractProductB{
public:
    virtual void displayB() = 0;

};

#endif

// ProductB1类
#ifndef _PRODUCTB1_HPP
#define _PRODUCTB1_HPP

#include<iostream>
#include"abstractproductb.hpp"

using namespace std;

class ProductB1 : public AbstractProductB {
public:
    virtual void displayB() override {
        cout << "ProductB1.displayB() is called" << endl;
    }
};

#endif

//ProductB2类
#ifndef _PRODUCTB2_HPP
#define _PRODUCTB2_HPP

#include<iostream>
#include"abstractproductb.hpp"

using namespace std;

class ProductB2 : public AbstractProductB {
public:
    virtual void displayB() override {
        cout << "ProductB2.displayB() is called" << endl;
    }
};

#endif

//客户端程序
#include<iostream>
#include"concretefactory1.hpp"
#include"concretefactory2.hpp"
#include"abstractproducta.hpp"
#include"abstractproductb.hpp"

using namespace std;
int main(){
    AbstractFactory* conF1= new ConcreteFactory1();
    AbstractProductA* pA1 =  conF1->createProductA();
    AbstractProductB* pB1 =  conF1->createProductB();
    pA1->displayA();
    pB1->displayB();

    AbstractFactory* conF2= new ConcreteFactory2();
    AbstractProductA* pA2 =  conF2->createProductA();
    AbstractProductB* pB2 =  conF2->createProductB();
    pA2->displayA();
    pB2->displayB();

    getchar();
    return 0;
}

输出结果：