简单工厂模式

       最近在看《大话设计模式》对于每章节的感想和思考想保留下来，所以特此开始写一写关于新学习的设计模式的东西，作为以后的参考。

       简单工厂模式就是说

1. 每个功能的实现，尽量分开，方便后续的继承和需求的增加，尽量松耦合；

2. 在多个功能实现的基础上，增加一个“工厂”作为一个接口，也就是功能的入口。

例子如下：

实现计算器，首选是一个抽象类-操作，作为操作符的父类

package  simplefactory;

public abstract class Operation {
	
    private double _numberA = 0;
    private double _numberB = 0;
    
    public Operation(double A,double B){
    	_numberA = A;
    	_numberB = B;
    }
    
    public double getNumberA(){
    	return _numberA;
    }
    public void setNumberA(double A){
    	this._numberA = A;
    }
    public double getNumberB(){
    	return _numberB;
    }
    public void setNumberB(double B){
    	this._numberA = B;
    }
    public abstract double getResult();
    
}

接下来分别是四个功能，加减乘除。

package simplefactory;


public class OperationAdd extends Operation{

	double A = 0;
	double B = 0;
	
	public OperationAdd(double A,double B ){
		super( A,  B);	
		this.A = A;
		this.B = B;
	}
	
	public  double getResult(){
		double result = 0;
		result = A + B;
	    return result;	
	}
}

package simplefactory;

public class OperationSub extends Operation {
    
	double A = 0;
	double B = 0;
	
	public OperationSub(double A,double B ){
		super( A,  B);		
		this.A = A;
		this.B = B;
	}
	
	public  double getResult(){
		double result = 0;
		result = A - B;
	    return result;	
	}
}

package simplefactory;

public class OperationMul extends Operation {
	
	double A = 0;
	double B = 0;
	
	public OperationMul(double A,double B ){
		super( A,  B);		
		this.A = A;
		this.B = B;
	}
	
	public  double getResult(){
		double result = 0;
		result = A * B;
	    return result;	
	}
}

package simplefactory;


public class OperationDiv extends Operation {

	double A = 0;
	double B = 0;
	
	public OperationDiv(double A,double B ){
		super( A,  B);	
		this.A = A;
		this.B = B;
	}
	
	public  double getResult(){
		double result = 0;
		try {
			result = A / B;
		} catch (Exception e) {
		 e.printStackTrace();
		}
	    return result;	
	}
}

然后是使用一个工程类来做创造实例的过程：

package simplefactory;

public class OperationFactory {

	public static Operation createOperate(String str,double A ,double B){
		Operation operate = null;
		switch(str){
		case "+" :
			operate = new OperationAdd(A,B);
			break;
		case "-" :
			operate = new OperationSub(A,B);
			break;
		case "*" :
			operate = new OperationMul(A,B);
			break;
		case "/" :
			operate = new OperationDiv(A,B);
			break;
		default :
			System.out.print("not have this operation!");
		}
		operate.setNumberA(A);
		operate.setNumberB(B);
		return operate;
	}
}

最后是客户端：

package simplefactory;

import java.util.ArrayList;
import java.util.List;

public class OperationClient {

	public static void main(String[] args) {
		
		double A = 15;
		double B = 5;
		double result = 0;
		List<String> str = new ArrayList<>();
		str.add("+");
		str.add("-");
		str.add("*");
		str.add("/");
		for(String ss : str){
			Operation operation = OperationFactory.createOperate(ss,A,B);
			System.out.println("这个操作符是 : "+ss+", 操作数A是 ： "+A+",操作数B是 ： "+B);
			result = operation.getResult();
			System.out.println("结果是 ： "+result);

		}
	}
}

结果如下：

这个操作符是 : +, 操作数A是 ： 15.0,操作数B是 ： 5.0
结果是 ： 20.0
这个操作符是 : -, 操作数A是 ： 15.0,操作数B是 ： 5.0
结果是 ： 10.0
这个操作符是 : *, 操作数A是 ： 15.0,操作数B是 ： 5.0
结果是 ： 75.0
这个操作符是 : /, 操作数A是 ： 15.0,操作数B是 ： 5.0
结果是 ： 3.0

总结：虽然简单工厂模式很简单，同时例子也很简单，但是，对于一个项目来说，一开始就能从松耦合、容易维护、尽量方便复用的角度考虑问题，很重要，思考习惯的改变，很难。