第八章 雷锋依然在人间---工厂方法模式(读书笔记)

一：简单工厂模式

简单工厂的UML图：

代码如下：

#include<iostream>  
#include<string>  
using std::cout;  
using std::endl;  
using std::cin;  
using std::string;  
  
//基类  
class Operation  
{  
public:  
    Operation():m_numberA(0),m_numberB(0)  
    {  
    };  
    Operation(double numberA,double numberB):m_numberA(numberA),m_numberB(numberB)  
    {  
    };  
    double getA()  
    {  
        return m_numberA;  
    };  
    double getB()  
    {  
        return m_numberB;  
    };  
    void setA(double number)    
    {    
        m_numberA = number;    
    };    
    void setB(double number)    
    {    
        m_numberB = number;    
    };    
    virtual double GetResult()//多态性  
    {  
        return 0;  
    }  
protected:  
    double m_numberA;  
    double m_numberB;  
};  
  
//加法类    
class OperationAdd :public Operation //继承  
{    
public:    
    double GetResult()    
    {    
        double result = 0;    
        result = m_numberA + m_numberB;    
        return result;    
    }    
};    
//减法类    
class OperationSub :public Operation    
{    
public:    
    double GetResult()    
    {    
        double result = 0;    
        result = m_numberA - m_numberB;    
        return result;    
    }    
};    
//乘法类    
class OperationMul :public Operation    
{    
public:    
    double GetResult()    
    {    
        double result = 0;    
        result = m_numberA * m_numberB;    
        return result;    
    }    
};    
//除法类    
class OperationDiv :public Operation    
{    
public:    
    double GetResult()    
    {    
        double result = 0;    
        if ( m_numberB == 0 )    
            throw "除数不能为0";    
        result = m_numberA / m_numberB;    
        return result;    
    }    
};    
//计算工厂设计模式  
class OperationFactory  
{  
public:  
    static Operation* createOperate(char oper)  //封装  
    {  
        Operation* myOper=NULL;  
        switch (oper)  
        {  
        case '+':  
            myOper=new OperationAdd();  
            break;  
            case '-':    
            myOper = new OperationSub();    
            break;    
        case '*':    
            myOper = new OperationMul();    
            break;    
        case '/':    
            myOper = new OperationDiv();    
            break;    
        default:  
            break;  
        };  
        return myOper;  
    }  
};  
  
void main()  
{  
    int operaterA,operaterB;  
    cout<<"请输入数字A"<<endl;  
    cin>>operaterA;  
    cout<<"请输入数字B"<<endl;  
    cin>>operaterB;  
    Operation* op=OperationFactory::createOperate('*');  
    op->setA(operaterA);  
    op->setB(operaterB);  
    cout<<operaterA<<" * "<<operaterB<<" 的结果为： "<<endl;  
    cout<<op->GetResult()<<endl;  
}

工厂方法的UML：

本次程序的UML：

代码实现如下：

#include<iostream>

#include<string>
using std::cout;
using std::endl;
using std::string;

class Operation  
{  
public:  
    Operation()  
        :m_numberA(0),m_numberB(0)  
    {  
    };  
    Operation(double numberA, double numberB)  
        :m_numberA(numberA),m_numberB(m_numberB)  
    {  
    };  
    double getA()  
    {  
        return m_numberA;  
    };  
    void setA(double number)  
    {  
        m_numberA = number;  
    };  
  
    double getB()  
    {  
        return m_numberB;  
    };  
    void setB(double number)  
    {  
        m_numberB = number;  
    };  
  
    virtual double GetResult()  
    {  
        return 0;  
    }  
protected:  
    double m_numberA;  
    double m_numberB;  
};  
  
class OperationAdd :public Operation  
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        result = m_numberA + m_numberB;  
        return result;  
    }  
};  
  
class OperationSub :public Operation  
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        result = m_numberA - m_numberB;  
        return result;  
    }  
};  
  
class OperationMul :public Operation  
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        result = m_numberA * m_numberB;  
        return result;  
    }  
};  
  
class OperationDiv :public Operation  
{  
public:  
    double GetResult()  
    {  
        double result = 0;  
        if ( m_numberB == 0 )  
            throw "被除数不能为零";  
        result = m_numberA / m_numberB;  
        return result;  
    }  
};

class IFactory  
{  
public:  
    virtual Operation* CreateOperation(void) = 0;  
};  
  
//加法工厂  
class AddFactory :public IFactory  
{  
public:  
    Operation* CreateOperation(void)  
    {  
        return new OperationAdd();  
    };  
};  
  
//减法工厂  
class SubFactory :public IFactory  
{  
public:  
    Operation* CreateOperation(void)  
    {  
        return new OperationSub();  
    };  
};  
  
//乘法工厂  
class MulFactory :public IFactory  
{  
public:  
    Operation* CreateOperation(void)  
    {  
        return new OperationMul();  
    };  
};  

//除法工厂  
class DivFactory :public IFactory  
{  
public:  
    Operation* CreateOperation(void)  
    {  
        return new OperationDiv();  
    };  
};  

int main()  
{  
    IFactory* operFactory = new AddFactory();  
    Operation* oper = operFactory->CreateOperation();  
  
    oper->setA(1);  
    oper->setB(2);  
    double result = oper->GetResult();  
	cout<<result<<endl;
    delete operFactory;  
    delete oper;  
    return 0;  
}  

1.简单工厂模式的最大优点在于工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类，对于客户端来说，去除了与具体产品的依赖。
2.工厂方法模式（Factory Method）定义一个用于创建对象的接口，让子类决定实例化哪一个类。工厂方法使一个类的实例化延迟到子类。
3.工厂方法模式的好处就是在扩展功能的时候，只要扩展了变化，不用修改现有的类了，也就完全符合了开放-封闭原则。
4.工厂方法把简单工厂的内部逻辑判断移到了客户端代码来进行。你想要加功能，搬来是改工厂类的，而现在是修改客户端。
5.工厂方法模式是简单工厂模式的进一步抽象和推广。由于使用了多态性，工厂方法模式保持了简单工厂模式的优点，而且克服了它的缺点。但缺点是由于每加一个产品，就需要加一个产品工厂的类，增加了额外的开发量。

抽象工厂的UML：