设计模式之工厂模式学习

与简单工厂模式相比，工厂模式为每个类增加了一个工厂类。每个工厂类返回它所对应的类的对象指针。

简单工厂模式的最大优点：工厂类中包含了必要的逻辑判断。根据客户端的选择条件动态的实例化相关的类。没有在客户端实现判断，也就去除了与客户端的依赖。

简单工厂模式实现计算类结构图：

工厂模式实现计算类结构图:

工厂模式实现代码：

#include<iostream>
using namespace std;
class Operation
{
	public:
	  double num1;
	  double num2;
	public:
	 Operation(double n1,double n2)
	 {
	 	num1=n1;
	 	num2=n2;
 		
 	 }
 	 virtual double calculate()=0;
};
class AddOperation:public Operation
{
	public:
	   AddOperation(double n1,double n2)
	      :Operation(n1,n2)
	   {
   		
   	   }
   	   virtual double calculate()
   	   {
   	   	  return num1+num2;
   	   }
	
};
class SubOperation:public Operation
{
	public:
	   SubOperation(double n1,double n2)
	      :Operation(n1,n2)
	   {
   		
   	   }
   	   virtual double calculate()
   	   {
   	   	  return num1-num2;
   	   }
	
};
class Factory
{
	public:
	  double n1;
	  double n2;
	public:
	  Factory(double n1,double n2)
	  {
  	     this->n1=n1;
  	     this->n2=n2;
  	  }
  	  virtual Operation *CreateOperation()=0;
	
};
class AddFactory:public Factory
{
   public:
     AddFactory(double n1,double n2)
         :Factory(n1,n2)
	 { 
 	  }	
 	  virtual Operation*CreateOperation()
 	  {
 	  	return new AddOperation(n1,n2);
  	 	
  	   }
};
class SubFactory:public Factory
{
   public:
     SubFactory(double n1,double n2)
       :Factory(n1,n2)
	 {
 		
 	  }	
 	  virtual Operation*CreateOperation()
 	  {
 	  	return new SubOperation(n1,n2);
  	 	
  	   }
};
int main(int argc,char**argv)
{
	double n1,n2;
	cin>>n1>>n2;
	
	cout<<AddFactory(n1,n2).CreateOperation()->calculate()<<endl;
	cout<<SubFactory(n1,n2).CreateOperation()->calculate()<<endl; 
	return 0;
}

对于简单工厂模式而言，如果需要添加新的计算功能类，如乘方类，就需要在简单工厂类中添加case分支条件，修改了原来的类，这违背了开放封闭原则。基于此引入了工厂模式。

工厂模式:定义一个用于创建对象的接口，让子类决定实例化那个类。工厂方法模式是一个类的实例化延迟到其子类。此时整个结构没有修改的变化，只是有扩展的变化。这完全符合开放封闭原则。但工厂方法实现时，客户端就需要判断实例化哪个工厂来实现运算类。选择判断仍然是必须的，工厂方法模式将简单工厂内部的逻辑判断移到了客户端进行判断。

对于大话设计模式中的雷锋工厂的例子。使用简单工厂模式时，每次实例化学生类或是志愿者类时，都需要简单工厂类的代码。在使用工厂模式时，会为每个雷锋类派生类，如学生类和志愿者类，都创建一个工厂类，用于生成该类所对应的对象。增加类时，只需要增加代码就可以了。很好的体现了开放封闭原则。

工厂类与简单工厂类实现雷锋工厂代码对比：

#include<iostream>
using namespace std;

class LeiFeng
{
	public:
	  LeiFeng()
	  {
  		
  	  }
  	  virtual void sweep()=0;
  	  virtual void wash()=0;
  	  virtual void buyRice()=0;
	
};
class Student:public LeiFeng
{
	public:
	  Student()
	  {
  		
  	  }
	   virtual void sweep()
	   {
   		std::cout<<"this student is sweeping now"<<std::endl;
   	   }
	   virtual void wash()
	   {
   		std::cout<<"this student is washing now"<<std::endl;
   	   }
		virtual void buyRice()
		{
		std::cout<<"this student is buying rice now"<<std::endl;
		}	   
   	
	
};
class Volunteer:public LeiFeng
{
	public:
	  Volunteer()
	  {
  		
  	  }
	   virtual void sweep()
	   {
   		std::cout<<"this Volunteer is sweeping now"<<std::endl;
   	   }
	   virtual void wash()
	   {
   		std::cout<<"this Volunteer is washing now"<<std::endl;
   	   }
		virtual void buyRice()
		{
		std::cout<<"this Volunteer is buying rice now"<<std::endl;
		}	   
   	
	
};
class SimpleFactory
{
	public:
	  LeiFeng *lf;
	public:
	  SimpleFactory()
	  {
  		lf=NULL;
  	  }
  	  LeiFeng* createLeiFeng(int type)
  	  {
  	  	switch(type)
  	  	{
  	  		case 1:
  	  		{
		  	  	lf=new Student;
	  	    }
	  	    break;
	  	    case 2:
	  	    {
    	  		lf=new Volunteer;
    	  	}
    	  	break;
	  	  	
 	     }
 	     return lf;
  	  }

	
};
class IFactory
{
	public:
	   IFactory()
	   {
   		
   	   }
   	   virtual LeiFeng*CreateLeiFeng()=0;
   	   
	
};
class StudentFactory:public IFactory
{
	public:
	 StudentFactory()
	 {
 		
 	 }
 	 virtual LeiFeng*CreateLeiFeng()
 	 {
 	 	return new Student;
 	 }
 	
};
class VolunteerFactory:public IFactory
{
	public:
	 VolunteerFactory()
	 {
 		
 	 }
 	 virtual LeiFeng*CreateLeiFeng()
 	 {
 	 	return new Volunteer;
 	 }
 	
};
int main(int argc,char**argv)
{
	LeiFeng *lf;
	/*
	SimpleFactory *sf=new SimpleFactory;
	lf=sf->createLeiFeng(1);
	lf->sweep();
	lf->wash();
	lf->buyRice();
	lf=sf->createLeiFeng(2);
	lf->sweep();
	lf->wash();
	lf->buyRice();*/
	
	
	lf=(new StudentFactory)->CreateLeiFeng();
	lf->sweep();
	lf->wash();
	lf->buyRice();
	lf=(new VolunteerFactory)->CreateLeiFeng();
	lf->sweep();
	lf->wash();
	lf->buyRice();
	
	
	
	
	return 0;
}

工厂模式克服了简单工厂模式违背开放封闭原则，保持了封装对象创建过程的优点。要更换对象时不需要做大的改动即可实现，降低了客户程序与产品对象的耦合度。