设计模式学习系列5 工厂模式

1 前言

先介绍一下面向对象设计的原则：

（1）OCP（开放关闭原则）：软件对扩展是开放的 ，对修改是关闭的，核心思想：对抽象编程，不对实现编程

（2）DIP（依赖倒转原则）：依赖于抽象，而不依赖实现

（3）LSP（李氏替换原则）：子类都可以替换父类

再看看上一篇文章中关于简单工厂模式的例子，如果现在需要扩展一个M的N次方这样一个元算，简单工厂类的话 只需要添加一个Operation继承一个运算子类，让后再Factorr工厂类中增加一个case分支皆可，但这样做的话就违背了OCP（开放关闭原则），如果处理的问题规模比较小，就像现在这种简单的元算情况，修改起来还是蛮方便的，但是在大型工程中，通过添加代码来扩展要更快捷，更安全一些。

2 工厂模式构成

UML图中，所有具体的工厂都从抽象接口继承，所有产品也由产品基类继承，并且每种产品工厂实现一种产品，这样的话，在软件中增加一种新功能就需要增减一个产品的子类，增加一个工厂的子类，然后在客户端中判断是否使用，这样程序的扩展不影响原先的功能，完全能够满足OCP原则。使用工厂模式后，相应的判断转移到客户手中，并没有因此减少哈

2 工厂模式构实现运算类

 #include <iostream>
  
 using namespace std;
 
 enum OperatorType
 {
     ADD = 1,
     SUB,
     MUL,
     DIV,
 };
 //运算类基类 
 class Operation
 {
public:
    double numA ;
    double numB ;    
public:
     Operation():numA(0),numB(0){}
     Operation(const double& a , const double& b)
     {
        numA = a ;
        numB = b ;      
    }
    virtual ~Operation(){}    
    
    void SetNumA(const double& a)
    {
        numA = a ;
    }
    
    void SetNumB(const double& b)
    {
        numB = b ;
    }
    
    virtual double GetResult()
    {
        return 0.0f ;    
    }        
 };
 
 
 //加法类
 class OperationAdd: public Operation
 {
     double GetResult()
     {
        return numA + numB ;      
    }
 };
  
  //减法类
 class OperationSub: public Operation
 {
     double GetResult()
     {
        return numA - numB ;      
    }
 };
 
 
 //乘法 
 class OperationMul: public Operation
 {
     double GetResult()
     {
        return numA * numB ;      
    }
 };
 
 
  //除法 
 class OperationDiv: public Operation
 {
     double GetResult()
     {
         if(numB == 0)
        {
             cout << "除数不能为0 
" << endl ;
             return 0 ;     
         } 
         
        return numA / numB ;      
    }
 };
 
 //工厂类接口 
 class IFactory
 {
    public:
        virtual Operation *CreateOperation(){} ;     
 };
 
 //加法工厂类
 class AddFactory:public IFactory
 {
     public:
     Operation *CreateOperation()
     {
         OperationAdd * p = new OperationAdd ;
         return p ;
      }     
 };
 class SubFactory:public IFactory
 {
     public:
     Operation *CreateOperation()
     {
         OperationSub * p = new OperationSub ;
         return p ;
      }     
 };
 
 class MulFactory:public IFactory
 {
     public:
     Operation *CreateOperation()
     {
         OperationMul * p = new OperationMul ;
         return p ;
      }     
 };
 
  class DivFactory:public IFactory
 {
     public:
     Operation *CreateOperation()
     {
         OperationDiv * p = new OperationDiv ;
         return p ;
      }     
 };
 
//===============================
  int main()
  {
        Operation *pOpe = 0 ;
        IFactory *Fac = new AddFactory;
        pOpe = Fac->CreateOperation();
        pOpe->SetNumA(10);
        pOpe->SetNumB(10);
        
 
        cout << pOpe->GetResult() << endl ;     
        
           delete pOpe; delete Fac; 
  }

3 工厂模式中增加新的功能

（1）增加一个新的运算类

 class OperationNew: public Operation
 {
     double GetResult()
     {
        return pow(numA,numB) ;      
    }
 };

（2）增加一个工厂类

 class NewFactory:public IFactory
 {
     public:
     Operation *CreateOperation()
     {
         OperationNew * p = new OperationNew ;
         return p ;
      }     
 };

4 总结

相对于简单工厂类，工厂类可能更加适合扩展吧，其实都要根据具体情况来说，这个模式相对简单，介绍到这里，下一篇抽象工厂模式。

细雨淅淅 标签: 设计模式

转载请注明地址：细雨淅淅