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

1.什么是简单工厂模式

　　简单工厂模式属于类的创建模式，又叫做静态工厂模式，是通过专门建立一个类负责创建其他类的实例，被创建的类通常有着共同的父类，之所以称之为工厂，就是因为负责创建其他类的类能够根据传递参数的不同，产生不同的实例，使得程序满足松耦合、重用度高、易修改维护的特点。

2.简单工厂模式的实现

　　下面举例说明工厂模式，比如说我们要实现一个两个数的size运算，那么如何去设计能过做到我们上面说的特性。首先我们要设定一个运算的终极父类：

#include <iostream>
#include <cstdio>
#include <string>
#include <map>
using namespace std;
class Operation
{
public:
    Operation():number_A(0),number_B(0){}
    virtual double getResult()
    {
        double result = 0;
        return result;
    }
    double number_A;
    double number_B;
};

　　这个类中，我们明确了目标，就是要根据输入的运算符不同，得到不同的结果，因此我们就要对各个运算符的类进行设计，如下所示：

 1 class OperationAdd:public Operation
 2 {
 3 public:
 4     double getResult()
 5     {
 6         double result = 0;
 7         result = number_A+number_B;
 8         return result;
 9     }
10 };
11
12 class OperationSub:public Operation
13 {
14 public:
15     double getResult()
16     {
17         double result = 0;
18         result = number_A-number_B;
19         return result;
20     }
21 };
22
23 class OperationMul:public Operation
24 {
25 public:
26     double getResult()
27     {
28         double result = 0;
29         result = number_A*number_B;
30         return result;
31     }
32 };
33
34 class OperationDiv:public Operation
35 {
36 public:
37     double getResult()
38     {
39         double result = 0;
40         result = number_A/number_B;
41         return result;
42     }
43 };

　　这些类完成以后，就相当于我们有了原料，那么这个时候，我们要做到事情就是，创建这样的一个工厂，这个工厂会根据用户的输入的变化，创造出不同的结果，其实根本上用到的就是我们所熟知的多态的特性，在这个例子中，所写的工厂如下。

class OperationFactory
{
public:
    static Operation* createOperation(string operate)
    {
        Operation *opt = NULL;
        std::map<string, int> mp;
        mp["+"] = 1;
        mp["-"] = 2;
        mp["*"] = 3;
        mp["/"] = 4;
        switch(mp[operate])
        {
            case 1: opt = new OperationAdd();break;
            case 2: opt = new OperationSub();break;
            case 3: opt = new OperationMul();break;
            case 4: opt = new OperationDiv();break;
        }
        return opt;
    }
};

　　这样就实现了加减乘除的工厂，在main函数中，我们就可以使用如下的方式实现：

int main(int argc, char const *argv[])
{
    Operation *opt;
    OperationFactory OF;

    string str = "/";
    opt->number_A = 10;
    opt->number_B = 100;

    opt = OF.createOperation(str);
    cout<<opt->getResult();

    return 0;
}

3.简单工厂模式的核心竞争力

　　首先，工厂模式统一的对象创建机制，优点是对于大规模的企业程序里要创建成千上万个对象，每个都去new，程序的业务逻辑就很混乱，统一由工厂创建，就比清晰。

　　然后就是他能够进一步的降低耦合，能够方便的进行修改和扩充，同时也能有效的保护原来写好程序的核心。