创建型模式-抽象工厂模式(abstract_factory)

抽象工厂

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

实例

main.cc:

#include "abstract_factory.h"
#include "abstract_cooker.h"
#include "abstract_washer.h"
#include "haier_factory.h"
#include "midea_factory.h"
#include "windows.h"
/*
design_pattern:"abstract_factory"
*/
int main()
{
    AbstractFactory* haier_factory = new HaierFactory();
    AbstractFactory* midea_factory = new MideaFactory();
    AbstractCooker* haier_cooker = haier_factory->CreateCooker();
    AbstractWasher* haier_washer = haier_factory->CreateWasher();
    AbstractCooker* midea_cooker = midea_factory->CreateCooker();
    AbstractWasher* midea_washer = midea_factory->CreateWasher();
    haier_cooker->Cooking();
    haier_washer->Clothing();
    midea_cooker->Cooking();
    midea_washer->Clothing();

    //clear
    delete haier_factory;
    delete midea_factory;
    delete haier_cooker;
    delete haier_washer;
    delete midea_cooker;
    delete midea_washer;    
    system("Pause");
    return 0;
}

AbstractFactory:

//abstract_factory.h:
#define HELENDP_SOURCE_ABSTRACT_FACTORY_H_
#include "abstract_cooker.h"
#include "abstract_washer.h"

class AbstractFactory
{
public:
    AbstractFactory();
    virtual ~AbstractFactory();
    virtual AbstractCooker* CreateCooker() = 0;
    virtual AbstractWasher* CreateWasher() = 0;
};
#endif


//abstract_factory.cc:
#include "abstract_factory.h"

AbstractFactory::AbstractFactory(){
}

AbstractFactory::~AbstractFactory(){
}

HaierFactory:

//haier_factory.h:
#ifndef HELENDP_SOURCE_HAIER_FACTORY_H_
#define HELENDP_SOURCE_HAIER_FACTORY_H_
#include "abstract_factory.h"
#include "abstract_cooker.h"
#include "abstract_washer.h"

class HaierFactory:public AbstractFactory{
public:
    HaierFactory();
    ~HaierFactory();   
    AbstractCooker* CreateCooker();
    AbstractWasher* CreateWasher();
};
#endif


//haier_factory.cc
#include "haier_factory.h"
#include "haier_cooker.h"
#include "haier_washer.h"

HaierFactory::HaierFactory()
{
}

HaierFactory::~HaierFactory(){

}

AbstractCooker* HaierFactory::CreateCooker(){
    return new HaierCooker();
}

AbstractWasher* HaierFactory::CreateWasher(){
    return new HaierWasher();
}

MideaFactory:

//midea_factory.h
#ifndef HELENDP_SOURCE_MIDEA_FACTORY_H_
#define HELENDP_SOURCE_MIDEA_FACTORY_H_
#include "abstract_factory.h"
#include "abstract_cooker.h"
#include "abstract_washer.h"

class MideaFactory:public AbstractFactory{
public:

    MideaFactory();
    ~MideaFactory();   
    AbstractCooker* CreateCooker();
    AbstractWasher* CreateWasher();
};
#endif


//midea_factory.cc
#include "midea_factory.h"
#include "midea_cooker.h"
#include "midea_washer.h"

MideaFactory::MideaFactory(){

}

MideaFactory::~MideaFactory(){

}

AbstractCooker* MideaFactory::CreateCooker(){
    return new MideaCooker();
}

AbstractWasher* MideaFactory::CreateWasher(){
    return new MideaWasher();
}

AbstractWasher:

//abstract_washer.h
#ifndef HELENDP_SOURCE_ABSTRACT_WASHER_H_
#define HELENDP_SOURCE_ABSTRACT_WASHER_H_

class AbstractWasher{
public:
    AbstractWasher();
    virtual ~AbstractWasher();

    virtual void Clothing() = 0;
};
#endif


//abstract_washer.cc
#include "abstract_washer.h"

AbstractWasher::AbstractWasher(){

}

AbstractWasher::~AbstractWasher(){

}

HaierWasher:

//haier_washer.h
#ifndef HELENDP_SOURCE_HAIER_WASHER_H_
#define HELENDP_SOURCE_HAIER_WASHER_H_
#include "abstract_washer.h"

class HaierWasher:public AbstractWasher{
public:
    HaierWasher();
    ~HaierWasher();
    void Clothing();
};
#endif


//haier_washer.cc
#include "haier_washer.h"
#include <iostream>
using namespace std;

HaierWasher::HaierWasher(){

}

HaierWasher::~HaierWasher(){

}

void HaierWasher::Clothing(){
    cout << "Haier Washer Clothing!" << endl;
}

MideaWasher:

//midea_washer.h
#ifndef HELENDP_SOURCE_MIDEA_WASHER_H_
#define HELENDP_SOURCE_MIDEA_WASHER_H_
#include "abstract_washer.h"

class MideaWasher:public AbstractWasher{
public:
    MideaWasher();
    ~MideaWasher();
    void Clothing();
};
#endif


//midea_washer.cc
#include "midea_washer.h"
#include <iostream>
using namespace std;

MideaWasher::MideaWasher(){

}

MideaWasher::~MideaWasher(){

}

void MideaWasher::Clothing(){
    cout << "Midea Washer Clothing!" << endl;
}

AbstractCooker:

//abstract_cooker.h
#ifndef HELENDP_SOURCE_ABSTRACT_COOKER_H_
#define HELENDP_SOURCE_ABSTRACT_COOKER_H_

class AbstractCooker
{
public:
    AbstractCooker();
    virtual ~AbstractCooker();

    virtual void Cooking() = 0;
};
#endif


//abstract_cooker.cc
#include "abstract_cooker.h"

AbstractCooker::AbstractCooker(){
}

AbstractCooker::~AbstractCooker(){
}

HaierCooker:

//haier_cooker.h
#ifndef HELENDP_SOURCE_HAIER_COOKER_H_
#define HELENDP_SOURCE_HAIER_COOKER_H_
#include "abstract_cooker.h"

class HaierCooker:public AbstractCooker{
public:
    HaierCooker();
    ~HaierCooker();
    void Cooking();
};
#endif


//haier_cooker.cc
#include "haier_cooker.h"
#include <iostream>
using namespace std;

HaierCooker::HaierCooker(){

}
HaierCooker::~HaierCooker(){

}
void HaierCooker::Cooking(){
    cout << "Haier Cooker Cooing!" << endl;
}

MideaCooker:

//midea_cooker.h
#ifndef HELENDP_SOURCE_MIDEA_COOKER_H_
#define HELENDP_SOURCE_MIDEA_COOKER_H_
#include "abstract_cooker.h"

class MideaCooker:public AbstractCooker{
public:
    MideaCooker();
    ~MideaCooker();
    void Cooking();
};
#endif


//midea_cooker.cc
#include "midea_cooker.h"
#include <iostream>
using namespace std;

MideaCooker::MideaCooker(){

}

MideaCooker::~MideaCooker(){

}

void MideaCooker::Cooking(){
    cout << "Midea Cooker Cooing!" << endl;
}

代码和UML图(EA)工程文件,最后会整理打包上传.

UML类图

结构

• AbstractFactory(AbstractFactory):抽象工厂
• ConcreteFactory(HaierFactory,MideaFactory):具体工厂
• AbstractProduct(AbstractWasher,AbstractCooker):抽象产品
• ConcreteProduct(HaierWasher,MideaWasher,HaierCooker,MideaCooker);具体产品

优点

• 抽象工厂模式隔离了具体类的生成，使得客户并不需要知道什么被创建。由于这种隔离，更换一个具体工厂就变得相对容易。所有的具体工厂都实现了抽象工厂中定义的那些公共接口，因此只需改变具体工厂的实例，就可以在某种程度上改变整个软件系统的行为。另外，应用抽象工厂模式可以实现高内聚低耦合的设计目的，因此抽象工厂模式得到了广泛的应用。
• 当一个产品族中的多个对象被设计成一起工作时，它能够保证客户端始终只使用同一个产品族中的对象。这对一些需要根据当前环境来决定其行为的软件系统来说，是一种非常实用的设计模式。
• 增加新的具体工厂和产品族很方便，无须修改已有系统，符合“开闭原则”

缺点

• 在添加新的产品对象时，难以扩展抽象工厂来生产新种类的产品，这是因为在抽象工厂角色中规定了所有可能被创建的产品集合，要支持新种类的产品就意味着要对该接口进行扩展，而这将涉及到对抽象工厂角色及其所有子类的修改，显然会带来较大的不便。
• 开闭原则的倾斜性（增加新的工厂和产品族容易，增加新的产品等级结构麻烦）。