设计模式之我见--1 简单工厂模式

本文所写都是自己的理解，可能会有错误，如果有错误请指出。

如果我们在控制台下做一个计算器，可能我们很容易就很快写出来了。其中可能有一部分人会认为就是输入两个数然后再输入运算符，然后使用if-else或者switch-case语句，进行分支判断计算，然后输出结果就可以了。这个虽然是完成了功能，但是如果我们想要复用这段代码的话就不可能了，因为这个代码是只能在这个程序中使用的。可能很多人都认为这个程序是比较简单的，这样已经做到饿很好了，但是简单的时候我们都不多想想，能到复杂了之后，我们想去认真想的时候，可能就不知道从什么地方下手了。所以还是在简单的时候多想想吧。

对于一个简单的计算器，可能在控制台下这样实现就已经很棒了。但是如果我们要求在手机上、PDA上都实现计算器，我们又得重新去写这些代码。等到我们都写完了之后，我们会发现，它们的不同就是在表示上，内部的运算逻辑都是相同的，我们相同的代码写了好几次，我们现在可能就会考虑了，如果我们把这些内部的逻辑分离开来，那我就可以再下次需要使用的时候直接拿过来用了。这样就可以将原先的复制代码改为复用代码了。

简单工厂模式，是在将业务逻辑进行分割，使业务之间的耦合度降低。在这个计算器中我们将+-*/分别表示为四个不同的类。然后使用一个工厂，根据需要产生不同的对象。下面是代码：

package caculator;
import java.io.BufferedReader; 
import java.io.IOException;
import java.io.InputStreamReader;

public class Caculator {
	public static void main(String[] args) {
		try
		{
			System.out.println("A:");
			BufferedReader brA = new BufferedReader(new InputStreamReader(System.in));
	        String strNumberA = null;
	        strNumberA = brA.readLine();
			double NumberA = Double.parseDouble(strNumberA);
			
			
			System.out.println("Oper:");
			BufferedReader brOper = new BufferedReader(new InputStreamReader(System.in));
	        String strOper = null;
	        strOper = brA.readLine();
			
			
	        System.out.println("B:");
			BufferedReader brB = new BufferedReader(new InputStreamReader(System.in));
	        String strNumberB = null;
	        strNumberB = brB.readLine();
			double NumberB = Double.parseDouble(strNumberB);
		
			Operation oper;
			oper = OperationFactory.createOperation(strOper);
			oper.setNumberA(NumberA);
			oper.setNumberB(NumberB);
			double result = oper.GetResult();
			System.out.println(result);
		}
		catch(IOException ex)
		{
			System.out.println(ex.toString());
		}
	}
}

这个是程序的主函数，下面是一个抽象的运算符的父类：

package caculator;

public abstract class Operation {
	private double _numberA=0;
	private double _numberB=0;
	
	public double getNumberA(){
		return _numberA;
	}
	public void setNumberA(double value){
		_numberA = value;
	}
	
	public double getNumberB(){
		return _numberB;
	}
	public void setNumberB(double value){
		_numberB = value;
	}
	
	public abstract double GetResult();

}

这个是作为运算符的父类，+-*/实际的运算符都继承了这个类，是为了在工厂中使用同一个变量来代表不同的类的实例。下面给出工厂类：

package caculator;

public class OperationFactory {
	public static Operation createOperation(String operate) {
		Operation oper = null;
		if ("+".equals(operate))
			oper = new OperationAdd();
		else if ("-".equals(operate))
			oper = new OperationSub();
		else if ("*".equals(operate))
			oper = new OperationMul();
		else if ("/".equals(operate))
			oper = new OperationDiv();
		/*switch (operate) {//java中switch语句不支持String作为选择符
		case "+":
			oper = new OperationAdd();
			break;
		case "-":
			oper = new OperationSub();
			break;
		case "*":
			oper = new OperationMul();
			break;
		case "/":
			oper = new OperationDiv();
			break;
		}*/
		return oper;
	}
}

下面给出一个+运算符类，其他的都类似，就不全部列出了：

package caculator;

public class OperationAdd extends Operation {
	@Override
	public double GetResult() {
		double result = 0;
		result = this.getNumberA() + this.getNumberB();
		return result;
	}
}

这个程序的类图如下：

在工厂中我们有一个operation的实例，但是实际返回的是根据我们要求返回的对应的运算符的实例。

简单工厂方法与前面说的方法比较，优点是我们如果添加一个新的运算符，我们只需要添加一个新的继承字operation的类，然后修改一下工厂方法就可以了。其他的类都不用修改就可以使用。这样我们以后如果需要只需要将类拿过去用就可以了。