Chapter01简单工厂模式

 一、UML类图

 

面向对象编程时，在整理对象之间关系时，用UML类图梳理，会更加清晰。

二、简单工厂模式

1.简单工厂模简介

简单工厂模式，利用一个工厂来生产不同类型的对象，达到服务层代码根据需求更改时，客户端代码接口不用进行修改。客户端可直接创建自己新增的需求对象并进行操作。由于比较简单，见代码很容易理解，故不做赘述。

2.C++代码如下

//定义基础操作类
#ifndef _MOPERATORDP_HPP
#define _MOPERATORDP_HPP

class OperatorDP{
    public:
    OperatorDP() = default;

    double getNum1() const {return num1;}
    double getNum2() const {return num2;}
    void setNum1(double num){num1 = num;}
    void setNum2(double num){num2 = num;}

    virtual double getResult(){};

    private:
    double num1;
    double num2;
};

#endif

// 定义加法类
#ifndef _MADDDP_HPP
#define _MADDDP_HPP

#include"operatordp.hpp"

class AddDP : public OperatorDP{

    public:
    AddDP() = default;
    virtual double getResult() override{
        return getNum1() + getNum2();
    }
};
#endif

//定义减法类
#ifndef _SUBTRACTDP_HPP
#define _SUBTRACTDP_HPP
#include"operatordp.hpp"

class SubtractDP:public OperatorDP{
    public:
    SubtractDP() = default;
    virtual double getResult(){
        return getNum1() - getNum2();
    }
};

#endif

//定义乘法类
#ifndef _MULTIPLYDP_HPP
#define _MULTIPLYDP_HPP

#include"operatordp.hpp"

class MultiplyDP:public OperatorDP{
    public:
    MultiplyDP() = default;
    virtual double getResult() override{
        return getNum1() * getNum2();
    }
};

#endif

//定义除法类
#ifndef _DIVIDEDP_HPP
#define _DIVIDEDP_HPP

#include<iostream>
#include<cmath>
#include"operatordp.hpp"

using namespace std;
class DivideDP : public OperatorDP{
    public:
    DivideDP() = default;
    virtual double getResult() override{
    
        if(abs(getNum2()) < e){
            cout << "divisor can't be zero"<<endl;
            getchar();
            abort();
        }
        else{
            return getNum1() / getNum2();
        }
        
    }
    private:
    static const double e;
};
const double DivideDP::e = 0.000000000001;

#endif

//定义工厂类
#ifndef _FACTORY_HPP
#define _FACTORY_HPP

#include<string>
#include"adddp.hpp"
#include"multiplydp.hpp"
#include"subtractdp.hpp"
#include"dividedp.hpp"
#include"operatordp.hpp"
using namespace std;

class Factory{
    public:
    static OperatorDP* creatObj(char op){
        switch(op){
            case '+':
            return new AddDP();
            case '-':
            return new SubtractDP();
            case '*':
            return new MultiplyDP();
            case '/':
            return new DivideDP();
            default:
            return nullptr;
        }
    }

};

#endif

// 客户端测试
#include<iostream>
#include"operatordp.hpp"
#include"Factory.hpp"

using namespace std;

int main(){
    OperatorDP* oper;
    double result;
    oper = Factory::creatObj('*'); 
    oper->setNum1(5);
    oper->setNum2(2);
    result = oper->getResult();
    cout << result << endl;
    getchar();
    return 0;
}

通过代码我们很容易就能发现，如果客户想新增加一个需求比如指数运算，那么只需新建一个继承OperatorDP的指数类，然后实现里面的方法getResult()就行了。并在工厂的swith中添加对应的质数运算，对客户端来说，只需调用工厂生产对应的对象，并调用对象的方法getResult()，从而得到结果。可见客户使用方法没变。服务端代码也实现了解耦，使代码更加易于维护。