创建型模式-抽象工厂模式(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);具体产品

优点

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

缺点

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