简单工厂模式 http://tcrct.javaeye.com/blog/468673

因购买了一本大话设计模式，看完第一章简单工厂模式，相信这个是我们用得最多的一个设计模式了吧。记得以前老师说常说工厂模式就好像你拿一些原材料到工厂加工，工厂加工后给你返回成品。
书中以一个简单的计算器来表达简单工厂模式，书中的例子是c#或C++的，现更改一下，用java来表达一下：

 package  chapter1.dao;

 public   abstract   class  Operation {

     /**
      * 定义两个输入数
      */
     private   double  numberA;
     private   double  numberB;
     /**
      * 定义一个抽像方法，让每个操作类都实现这个方法
      * @return
      */
     public   abstract   double  getResult();

     public   double  getNumberA() {
         return  numberA;
     }
     public   void  setNumberA( double  numberA) {
         this .numberA = numberA;
     }
     public   double  getNumberB() {
         return  numberB;
     }
     public   void  setNumberB( double  numberB) {
         this .numberB = numberB;
     }

 }

package chapter1.dao;

public abstract class Operation {
	
	/**
	 * 定义两个输入数
	 */
	private double numberA;
	private double numberB;
	/**
	 * 定义一个抽像方法，让每个操作类都实现这个方法
	 * @return
	 */
	public abstract double getResult();
	
	public double getNumberA() {
		return numberA;
	}
	public void setNumberA(double numberA) {
		this.numberA = numberA;
	}
	public double getNumberB() {
		return numberB;
	}
	public void setNumberB(double numberB) {
		this.numberB = numberB;
	}
	
}

相对应地生成加减乘除操作类

 /**
  * 定义加法操作类
  * @author Administrator
  *
  */
 public   class  OperationAdd  extends  Operation  {

     @Override
     public   double  getResult() {
         return  getNumberA() +  getNumberB();
     }

 }

/**
 * 定义加法操作类
 * @author Administrator
 *
 */
public class OperationAdd extends Operation  {

	@Override
	public double getResult() {		
		return getNumberA() +  getNumberB();
	}

}

 

 /**
  * 定义减法操作类
  * @author Administrator
  *
  */
 public   class  OperationSub  extends  Operation {

     @Override
     public   double  getResult() {
         return  getNumberA() -  getNumberB();
     }

 }

/**
 * 定义减法操作类
 * @author Administrator
 *
 */
public class OperationSub extends Operation {

	@Override
	public double getResult() {	
		return getNumberA() -  getNumberB();
	}

}

 

 /**
  * 定义乘法操作类
  * @author Administrator
  *
  */
 public   class  OperationMul  extends  Operation {


     public   double  getResult() {
         return  getNumberA() *  getNumberB();
     }

 }

/**
 * 定义乘法操作类
 * @author Administrator
 *
 */
public class OperationMul extends Operation {

	 
	public double getResult() {		
		return getNumberA() *  getNumberB();
	}

}

 

 /**
  * 定义除法操作类
  * @author Administrator
  *
  */
 public   class  OperationDiv  extends  Operation{


     public   double  getResult() {
     if ( 0 ==getNumberB()){
     throw   new  IllegalArgumentException( "除数不能为零!" );
     }
     return  getNumberA() /  getNumberB();
     }

 }

/**
 * 定义除法操作类
 * @author Administrator
 *
 */
public class OperationDiv extends Operation{

	
    public double getResult() {
	if(0==getNumberB()){
	throw new IllegalArgumentException("除数不能为零!");
	}
	return getNumberA() /  getNumberB();
    }

}

再生成一个工厂类，

 **
  * 运算的工厂类
  * @author  Administrator
  *
  */
 public   class  OperationFactory {

     public   static  Operation createOperation(String option){
         Operation oper = null ;
         if ( "+" .equals(option)){
             oper = new  OperationAdd();
         }else   if ( "-" .equals(option)){
             oper = new  OperationSub();
         }else   if ( "*" .equals(option)){
             oper = new  OperationMul();
         }else   if ( "/" .equals(option)){
             oper = new  OperationDiv();
         }else   if ( "#" .equals(option)){
             oper = new  OperationSqu();
         }
         return  oper;

     }
 }

**
 * 运算的工厂类
 * @author Administrator
 *
 */
public class OperationFactory {
	 
	public static Operation createOperation(String option){
		Operation oper = null;
		if("+".equals(option)){
			oper = new OperationAdd();
		}else if("-".equals(option)){
			oper = new OperationSub();
		}else if("*".equals(option)){
			oper = new OperationMul();
		}else if("/".equals(option)){
			oper = new OperationDiv();
		}else if("#".equals(option)){
			oper = new OperationSqu();
		}
		return oper;
		
	}
}

视图层：

 public   class  OperationView {

 public   static   void  main(String[] args) {
     Operation oper = OperationFactory.createOperation("+" );
     oper.setNumberA(5L);
     oper.setNumberB(0L);
     System.out.println("结果为：" +oper.getResult());

 }

 }

public class OperationView {

public static void main(String[] args) {
	Operation oper = OperationFactory.createOperation("+");
	oper.setNumberA(5L);
	oper.setNumberB(0L);
	System.out.println("结果为："+oper.getResult());

}

}

此时，Operation就是原材料，OperationAdd就是加工方法，OperationFactory就是加工厂，传入去的option参数就是客户的要求。就像是加工厂按客户要求找出符合的加工方法，再用加工方法对原材料进行加工，并返回成品。

如果需要添加新功能，则只需要在工厂类里添加一个操作分支，然后再增加相对应的运算子类即可，若需要对现有的功能进行修改，只需要对要修改的子类进行修改。实现松耦合。让子类与子类之间独立起来，互不影响！