设计模式之工厂模式系列（简单工厂，工厂模式，抽象工厂模式）

每次在做功能时，都会考虑下具体的应该采用神马样的设计模式，今天索性就来整体地学习下我们常用的一些设计模式了，首先是我们的工厂模式系列，在这类模式中，主要分为了三大类：简单工厂模式，工厂方法模式以及抽象工厂模式，它们之间的不同：简单的工厂模式可以比做成一个工厂但是可以生产不同的物品，工厂模式就是不同的工厂生产不同的物件，而抽象工厂则是不同的工厂既可以生产相同的物件也可以生产不同的物件，个人的感觉就是一个比一个包含的范围广，一个比一个复杂，这个是必须的，下面我们就从最简单的开始。

1.简单工厂模式

  这种模式在上面也提及到了，就是一个工厂生产不同的物件，工厂只有一个，而物件可以多个，代码如下：

#ifndef __SIMPLE_FACTORY_H
#define __SIMPLE_FACTORY_H
#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

class Object
{
    public:
        virtual void showName() = 0;
};

class Watch : public Object
{
    public:
        void showName()
        {
            cout<<"Watch"<<endl;
        }
};

class Pen : public Object
{
    public:
        void showName()
        {
            cout<<"Pen"<<endl;
        }
};
class SimpleFactory
{
    public:
        Object* createObject(int type)
        {
            switch(type)
            {
                case 1://watch
                    return new Watch();
                    break;
                case 2:
                    return new Pen();
                    break;
                default:
                    return NULL;
            }
        }
};
#endif
#include "SimpleFactory.h"
int main()
{
    SimpleFactory factory;
    shared_ptr<Object> obj1(factory.createObject(1));
    obj1->showName();
    shared_ptr<Object> obj2(factory.createObject(2));
    obj2->showName();
    return 0;
}

从上述代码中可以看到，简单工厂的最大的不足就是：生产线很单一，并且只有一个工厂，如果需要增加生产线的话，还的修改工厂方法，因此，在此基础上，工厂方法应运而生了，工厂方法相比简单工厂，其最大的特点就是如果要开启新的生产线的话，我可以建立新的工厂，而不是在已有的工厂里面添加生产线。

2.工厂模式

#ifndef __SIMPLE_FACTORY_H
#define __SIMPLE_FACTORY_H
#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

class Object
{
    public:
        virtual void showName() = 0;
};

class Watch : public Object
{
    public:
        void showName()
        {
            cout<<"Watch"<<endl;
        }
};

class Pen : public Object
{
    public:
        void showName()
        {
            cout<<"Pen"<<endl;
        }
};

class Factory
{
    public:
        virtual Object* createObject() = 0;
};

class WatchFactory : public Factory
{
    public:
        Object* createObject()
        {
            return new Watch();
        }
};
class PenFactory : public Factory
{
    public:
        Object* createObject()
        {
            return new Pen();
        }
};
#endif
#include "SimpleFactory.h"


int main()
{
    shared_ptr<Factory> fac1(new WatchFactory);
    shared_ptr<Object> obj1(fac1->createObject());
    obj1->showName();

    shared_ptr<Factory> fac2(new PenFactory);
    shared_ptr<Object> obj2(fac2->createObject());
    obj2->showName();
    return 0;
}

从上述代码中可以看出，工厂模式最大的问题就是每次新增加一个产品线就得新加一个工厂，这样的话代价就太大了，并且如果需要每个工厂即生产相同的品种的物品，又要生产不同品种的物品，上述的两种形式很难实现，下面就该抽象工厂出厂了。

3.抽象工厂

   抽象工厂定义为提供一个创建一系列相关或相互依赖对象的接口，而无需指定它们具体的类，下面就来看看代码吧

#ifndef __SIMPLE_FACTORY_H
#define __SIMPLE_FACTORY_H
#include <iostream>
#include <boost/smart_ptr.hpp>
using namespace std;
using namespace boost;

class Object
{
    public:
        virtual void showName() = 0;
};

class Object1
{
    public:
        virtual void showName() = 0;
};

class Watch : public Object
{
    public:
        void showName()
        {
            cout<<"Watch"<<endl;
        }
};

class Pen : public Object
{
    public:
        void showName()
        {
            cout<<"Pen"<<endl;
        }
};

class Car : public Object1
{
    public:
        void showName()
        {
            cout<<"Car"<<endl;
        }
};
class Plane : public Object1
{
    public:
        void showName()
        {
            cout<<"Plane"<<endl;
        }
};

class AbsFactory
{
    public:
        virtual Object* createObject() = 0;
        virtual Object1* createObject1() = 0;
};

class WatchFactory : public AbsFactory
{
    public:
        Object* createObject()
        {
            return new Watch();
        }
        Object1* createObject1()
        {
            return new Car();
        }
};

class PenFactory : public AbsFactory
{
    public:
        Object* createObject()
        {
            return new Pen();
        }
        Object1* createObject1()
        {
            return new Plane();
        }
};
#endif

#include "SimpleFactory.h"


int main()
{
    shared_ptr<AbsFactory> abFac1(new WatchFactory);
    shared_ptr<Object> obj1(abFac1->createObject());
    shared_ptr<Object1> obj2(abFac1->createObject1());
    obj1->showName();
    obj2->showName();

    shared_ptr<AbsFactory> abFac2(new PenFactory());
    shared_ptr<Object> obj3(abFac2->createObject());
    shared_ptr<Object1>obj4(abFac2->createObject1());
    obj3->showName();
    obj4->showName();
    return 0;
}

总结

       工厂模式在实际的使用中界限不会很明显，其主要的目的就是为了实现抽象与接口分离，使得用户不用过多地关注起实现，而是专注于业务逻辑，因此工厂方法在一定程度上能够降低类之间的耦合度，上面的几个测试案例已经说明了这点，基本上通过调用抽象出来的接口接口完成相应的任务，起到了很好的封装作用。好了，本篇博文到此结束，多谢

如果需要，请注明转载，多谢