设计模式（一）——Factory模式

在面向对象设计的过程中，总是会遇到两个问题：1）为了提高高内聚，低耦合，我们常常抽象出一些类的公共接口定义成抽象基类或接口。这样通过定义一个基类的指针来指向实际的基类来达到多态的目的。这里面临的一个问题就是，给指针赋值的之后，我们必须明确指针指向对象的类型，在某些类名不具有自解释性的时候，就会面临很大的问题。2）程序的扩展性和可维护性就很难了。

下面进入正题，介绍Factory的两个比较重要的功能：

1）定义创建对象的接口，封装了对象的创建。

2）使得具体化的工作延迟到子类中。

Factory模式示意如下：

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

//Product.cpp
#include "Product.h"
#include <iostream>
using namespace std;
Product::Product()
{
}
Product::~Product()
{
}
ConcreteProduct::ConcreteProduct()
{
cout<<"ConcreteProduct...."<<endl;
}
ConcreteProduct::~ConcreteProduct()
{
}

Factory.h

<pre name="code" class="cpp">代码片断3：Factory.h
//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();
}

</pre><pre name="code" class="cpp">

这个例子可以看出，我们将Factory的具体实现都延迟到子类中，解决了父类不知道具体实例化哪个子类的问题。