Factory mode（工厂模式）

Factory mode（工厂模式）

产生的背景

在面向对象系统设计中经常可以遇到以下的两类问题：

• 我们经常会抽象出一些类的公共接口以形成抽象基类或者接口。这样我们可以通过声明一个指向基类的指针来指向实际的子类实现，达到了多态的目的。所以就不得不在要用到子类的地方写new 对象。这样实体类的使用者必须知道实际的子类名称，以及会使程序的扩展性和维护变得越来越困难。
• 还有一种情况就是在父类中并不知道具体要实例化哪一个具体的子类。只能在父类中写方法调用，具体调用哪一个类的方法交给子类实现。

所以，就产生了工厂模式解决

1. 定义创建对象的接口，封装了对象的创建
2. 使得具体化类的工作延迟到子类中

 

//Product.h 
#ifndef _PRODUCT_H_ 
#define _PRODUCT_H_ 
class Product 
{ 
public: 
virtual ~Product() = 0; protected: Product(); 
private: 
}; 
class ConcreteProduct:public Product 
{ 
public: ~ConcreteProduct(); ConcreteProduct(); protected: 
private: 
}; 
#endif //~_PRODUCT_H_//Product.cpp 
#include "Product.h" 
#include <iostream> 
using namespace std; 
Product::Product() 
{ } 
Product::~Product() 
{ 
} 
ConcreteProduct::ConcreteProduct() 
{ cout<<"ConcreteProduct...."<<endl; 
} 
ConcreteProduct::~ConcreteProduct() 
{ 
}//Factory.h 
#ifndef _FACTORY_H_ 
#define _FACTORY_H_ 
class Product; 
class Factory 
{ 
public: 
virtual ~Factory() = 0;
virtual Product* CreateProduct() = 0; 
protected: Factory(); 
private: 
class ConcreteFactory:public Factory
{ 
public: ~ConcreteFactory(); ConcreteFactory(); Product* CreateProduct(); 
protected: 
private: 
}; 
#endif //~_FACTORY_H_ //Factory.cpp 
#include "Factory.h" 
#include "Product.h" 
#include <iostream> 
using namespace std; 
Factory::Factory() 
{ 
} 
Factory::~Factory() 
{
} 
ConcreteFactory::ConcreteFactory() 
{ cout<<"ConcreteFactory....."<<endl; 
} 
ConcreteFactory::~ConcreteFactory() 
{ 
} 
Product* ConcreteFactory::CreateProduct() 
{ 
return new ConcreteProduct(); 
} //main.cpp 
#include "Factory.h" 
#include "Product.h"
#include <iostream> 
using namespace std; 
int main(int argc,char* argv[])
{ 
Factory* fac = new ConcreteFactory(); 
Product* p = fac->CreateProduct(); return 0;
} 

总结：

• 如果为每一个具体的 ConcreteProduct 类的实例化提供一个函数体，那么我们可能不得不在系统中添加了一个方法来处理这个新建的ConcreteProduct
• 可以看出，Factory 模式对于对象的创建给予开发人员提供了很好的实现策略，但是Factory 模式仅仅局限于一类类（就是说Product 是一类，有一个共同的基类），如果我们要为不同类的类提供一个对象创建的接口，那就要用 AbstractFactory 了。

AbstactFactory 模式（抽象工厂模式）

假如我们要买水果，水果的产地来自中国、日本、美国，每个国家的水果种类都可以分为苹果、香蕉、梨子。作为开发者，我们就不得不创建苹果类（香蕉和梨子类似），然后每种苹果都继承自苹果类。每上架一个国家的苹果我们都要实现一次苹果类，这样就会有成千上万的苹果类需要被创建，AbstractFactory 模式就是用来解决这类问题的：要创建一组相关或者相互依赖的对象。

//抽象工厂模式
#include <iostream>
using namespace std;//苹果的抽象
class AbstractApple 
{
public:
    virtual void showName() = 0;
};//中国苹果
class ChinaApple :public AbstractApple
{
public:
    virtual void showName() {cout << "中国苹果" << endl;}
};//美国苹果
class USAApple :public AbstractApple 
{
public:
    virtual void showName() {cout << "美国苹果" << endl;}
};//日本苹果
class JapanApple :public AbstractApple 
{
public:
    virtual void showName() {cout << "日本苹果" << endl;}
};//香蕉的抽象
class AbstractBanana 
{
public:
    virtual void showName() = 0;
};//中国香蕉
class ChinaBanana :public AbstractBanana 
{
public:
    virtual void showName() {cout << "中国香蕉" << endl;}
};//美国香蕉
class USABanana :public AbstractBanana
{
public:
    virtual void showName() {cout << "美国香蕉" << endl;}
};//日本香蕉
class JapanBanana :public AbstractBanana 
{
public:
    virtual void showName() {cout << "日本香蕉" << endl;}
};//鸭梨的抽象
class AbstractPear 
{
public:
    virtual void showName() = 0;
};//中国鸭梨
class ChinaPear :public AbstractPear 
{
public:
    virtual void showName() {cout << "中国鸭梨" << endl;}
};//美国鸭梨
class USAPear :public AbstractPear 
{
public:
    virtual void showName() {cout << "美国鸭梨" << endl;}
};//日本鸭梨
class JapanPear :public AbstractPear 
{
public:
    virtual void showName() {cout << "日本鸭梨" << endl;}
};
//抽象工厂  针对产品族
class AbstractFactory {
public:
    virtual AbstractApple* CreateApple() = 0;
    virtual AbstractBanana* CreateBanana() = 0;
    virtual AbstractPear* CreatePear() = 0;
};
//中国工厂
class ChinaFactory :public AbstractFactory 
{
    virtual AbstractApple* CreateApple() 
{
    return new ChinaApple;
}
virtual AbstractBanana* CreateBanana() 
{
    return new ChinaBanana;
}
virtual AbstractPear* CreatePear() 
{
    return new ChinaPear;
}
};
//美国工厂
class USAFactory :public AbstractFactory
 {
    virtual AbstractApple* CreateApple() 
{
    return new USAApple;
}
virtual AbstractBanana* CreateBanana()
{
    return new USABanana;
}
virtual AbstractPear* CreatePear() 
{
    return new USAPear;
}
};//日本工厂
class JapanFactory :public AbstractFactory 
{
    virtual AbstractApple* CreateApple() 
{
    return new JapanApple;
}
virtual AbstractBanana* CreateBanana() 
{
    return new JapanBanana;
}
virtual AbstractPear* CreatePear() 
{
    return new JapanPear;
}
};
void test01() 
{
    AbstractFactory* factory = NULL;
    AbstractApple* apple = NULL;
    AbstractBanana* Banana = NULL;
    AbstractPear* Pear = NULL;
    //中国工厂
    factory = new ChinaFactory;
    apple = factory->CreateApple();
    Banana = factory->CreateBanana();
    Pear = factory->CreatePear();
    apple->showName();
    Banana->showName();
    Pear->showName();
    delete Pear;
    delete apple;
    delete Banana;
    delete factory;
}
int main()
{
    test01();
}

总结：

• AbstractFactory 模式和 Factory模式的区别是初学（使用）设计模式时候的一个容易引起困惑的地方。实际上，AbstractFactory模式是为创建一组（有多类）相关或依赖的对象提供创建接口，而 Factory模式是为一类对象提供创建接口或延迟对象的创建到子类中实现。并且可以看到，AbstractFactory模式通常都是使用 Factory 模式实现。