设计模式学习--工厂模式

设计模式学习–工厂模式

文章理论部分参考以下链接

http://www.runoob.com/design-pattern/factory-pattern.html

1. 工厂模式介绍

工厂模式（Factory Pattern）是最常用的设计模式之一。这种类型的设计模式属于创建型模式，它提供了一种创建对象的最佳方式。在工厂模式中，我们在创建对象时不会对客户端暴露创建逻辑，并且是通过使用一个共同的接口来指向新创建的对象。

意图：定义一个创建对象的接口，让其子类自己决定实例化哪一个工厂类，工厂模式使其创建过程延迟到子类进行。
主要解决：主要解决接口选择的问题。
何时使用：我们明确地计划不同条件下创建不同实例时。
如何解决：让其子类实现工厂接口，返回的也是一个抽象的产品。
关键代码：创建过程在其子类执行。
应用实例：您需要一辆汽车，可以直接从工厂里面提货，而不用去管这辆汽车是 怎么做出来的，以及这个汽车里面的具体实现。
优点： 1、一个调用者想创建一个对象，只要知道其名称就可以了。
2、扩展性高，如果想增加一个产品，只要扩展一个工厂类就可以。
3、屏蔽产品的具体实现，调用者只关心产品的接口。
缺点：
每次增加一个产品时，都需要增加一个具体类和对象实现工厂，使得系统中类的个数成倍增加，在一定程度上增加了系统的复杂度，同时也增加了系统具体类的依赖。这并不是什么好事。
使用场景：
1、日志记录器：记录可能记录到本地硬盘、系统事件、远程服务器等，用户可以选择记录日志到什么地方。
2、数据库访问，当用户不知道最后系统采用哪一类数据库，以及数据库可能有变化时。
3、设计一个连接服务器的框架，需要三个协议，”POP3”、”IMAP”、”HTTP”，可以把这三个作为产品类，共同实现一个接口。
注意事项：
作为一种创建类模式，在任何需要生成复杂对象的地方，都可以使用工厂方法模式。有一点需要注意的地方就是复杂对象适合使用工厂模式，而简单对象，特别是只需要通过 new 就可以完成创建的对象，无需使用工厂模式。如果使用工厂模式，就需要引入一个工厂类，会增加系统的复杂度。

抽象基类：
1、Product:创建出来的对象的抽象基类.
2、 Factory 创建对象的工厂方法的抽象基类.

接口函数： Creator::FactoryMethod:纯虚函数,由派生类实现,创建出对应的 Product.

解析：
在这个模式中，有两个抽象基类,一个是 Product 为创建出来的对象的抽象基类，一个是 Factory 是工厂的抽象基类,在互相协作的时候都是由相应的 Factory 派生类来生成Product 的派生类,也就是说如果要新增一种 Product 那么也要对应的新增一个Factory, 创建的过程委托给了这个 Factory.也就是说一个 Factory 和一个Product 是一一对应的关系.

备注：设计模式的演示图上把 Factory 类命名为 Creator,下面的实现沿用了这个命名.

实现演示：

1、创建一个产品的抽象基类

class Product
{
public:
    Product(){}
    virtual ~Product(){}
};

2、创建具体产品类，继承抽象基类

class ConcreteProduct:public Product
{
public:
    ConcreteProduct()
    { 
        cout<<"construction of ConcreteProduct"<<endl; 
    }
    virtual ~ConcreteProduct()
    {
        cout<<"destruction of ConcreteProduct"<<endl; 
    }
};

3、创建一个抽象工厂类

class Creator
{
public:
    Creator(){}
    virtual ~Creator(){}
    void AnOperation()
    {
        Product* p = FactoryMethod();
        cout<<"an operation of product"<<endl;
    }
protected:
    virtual Product* FactoryMethod()=0;
};

4、创建一个具体工厂类

class ConcreteCreator:public Creator
{
public:
    ConcreteCreator()
    { 
        cout<<"construction of ConcreteCreator"<<endl; 
    }
    virtual ~ConcreteCreator()
    { 
        cout<<"destruction of ConcreteCreator"<<endl; 
    }
protected:
    virtual Product* FactoryMethod()
    { 
        return new ConcreteProduct(); 
    }
};

5、客户或者调用者

int main()
{ 
    Creator *p = new ConcreteCreator();
    p->AnOperation();
    delete p;
    return 0;
}

从上述过程可以看出，如果需要增加一个产品，我需要一下过程

//新的具体产品类
class ConcreteProduct2:public Product
{
public:
    ConcreteProduct2()
    { 
        cout<<"construction of ConcreteProduct2"<<endl; 
    }
    virtual ~ConcreteProduct2()
    {
        cout<<"destruction of ConcreteProduct2"<<endl; 
    }
};

//新的具体工厂类
class ConcreteCreator2:public Creator
{
public:
    ConcreteCreator2()
    { 
        cout<<"construction of ConcreteCreator2"<<endl; 
    }
    virtual ~ConcreteCreator2()
    { 
        cout<<"destruction of ConcreteCreator2"<<endl; 
    }
protected:
    virtual Product* FactoryMethod()
    { 
        return new ConcreteProduct2(); 
    }
};

//客户拥有了新的选择
int main()
{ 
    Creator *p;
    int type;
    cin>>type;
    switch(type)
    {
        case 1:
            p = new ConcreteProduct(); 
            break;
        case 2:
            p = new ConcreteProduct2(); 
            break;
    }
    p->AnOperation();
    delete p;
    return 0;
}

整体代码：

//Factory.cpp
//factory模式演示
#include<iostream>
using namespace std;
class Product
{
public:
    Product(){}
    virtual ~Product(){}
};

class ConcreteProduct:public Product
{
public:
    ConcreteProduct()
    { 
        cout<<"construction of ConcreteProduct"<<endl; 
    }
    virtual ~ConcreteProduct()
{ cout<<"destruction of ConcreteProduct"<<endl; }
};

class Creator
{
public:
    Creator(){}
    virtual ~Creator(){}
    void AnOperation()
    {
        Product* p = FactoryMethod();
        cout<<"an operation of product"<<endl;
    }
protected:
    virtual Product* FactoryMethod()=0;
};

class ConcreteCreator:public Creator
{
public:
    ConcreteCreator()
    { cout<<"construction of ConcreteCreator"<<endl; }
    virtual ~ConcreteCreator()
    { cout<<"destruction of ConcreteCreator"<<endl; }
protected:
    virtual Product* FactoryMethod()
    { return new ConcreteProduct(); }
};

int main()
{ 
    Creator *p = new ConcreteCreator();
    p->AnOperation();
    delete p;
    return 0;
}