设计模式第一重--简单工厂模式

我们来做一个计算器来解释一下什么叫简单工厂模式。

要求：设计一个计算器控制台程序，要求输入两个数和运算符号，得出结果。

首先这是我自己用java实现的：

1.获取控制台输入的值；

2.调用计算器方法得出结果。

package zjyange.design;

import java.util.Scanner;

public class Counter {

	public static void main(String[] args) {
		//获取控制台输入的值
		Scanner input = new Scanner(System.in);
		//获取第一个数
		System.out.print("输入第一个数：");
		Double x = input.nextDouble();
		//获取运算符
		System.out.print("输入运算符：");
		String operator = input.next();
		//获取第二个数
		System.out.print("输入第二个数：");
		Double y = input.nextDouble();
		Counter counter = new Counter();
		System.out.println("运算结果为：" + counter.operating(x,operator,y));
	}
	
	//计算器
	private Double operating(Double x,String operator,Double y){
		Double result = (double) 0;
		if(operator.equals("+")){
			result = x+y;
		}
		else if(operator.equals("-")){
			result = x-y;
		}
		else if(operator.equals("*")){
			result = x*y;
		}
		else if(operator.equals("/")){
			result = x/y;
		}
		else{
			System.out.println("不要使用非法运算符！");
		}
		return result;
	}
	
}

测试一遍，控制台输出的结果：

虽然完成了需求，但是这种代码问题有很大的安全性问题：

例如我要新加求余方法，那么我必须在原来的类对象中修改，修改的过程中很容易把以前的代码不小心修改了，这就导致了安全性的问题。简单工厂模式主要解决的是代码安全性的问题。

下面说一下简单工厂模式，简单工厂模式，就是使用一个工厂类来创建我们需要的对象，它的最大的特点就是面向对象，我们都知道面向对象有三大特点：封装，继承，多态，简单工厂很好的同时实现了这三个方面：我们将每个运算方法封装为了一个实现类，这是封装；每个实现类都继承了基础bean，这是继承；每个实现类中的countResult()方法具体逻辑都不一样，这是多态。这样我们在添加一个新的开平方根的方法时，添加一个新的类，这个类由工厂来新建，这个就使得我们不需要知道其他计算方法是怎么实现的，就可以加入新的计算方法，大大提高了代码的安全性。放大来说，在实际项目中，我们经常遇到的事情就是，第一期开发完毕之后，客户提出了一个小小的要求，要求加入一个字段或者一个新的需求，我们就不得不将代码每个位置都重新修改一遍。使用简单工厂模式之后，我们只需要添加新的需求实现类，然后再工厂类中加入这个新的需求，就大功告成了，省时又省力。

具体的代码实现：

首先我们需要一个bean，bean中有第一个数和第二个数，以及返回值：

package zjyange.finish;

public class Operate {
	
	public Double doubleA; 
	public Double doubleB;
	public Double getDoubleA() {
		return doubleA;
	}
	public void setDoubleA(Double doubleA) {
		this.doubleA = doubleA;
	}
	public Double getDoubleB() {
		return doubleB;
	}
	public void setDoubleB(Double doubleB) {
		this.doubleB = doubleB;
	}
	public Double countResult(){
		Double result = null;
		return result;
	}
}

接着，我们来分别实现运算方法，要注意，这里使用了继承：每个运算类都继承了基础bean，所以可以使用bean中的属性，省去了每个类中都需要创建新的属性；同时每个运算类都重写了基础bean中的countResult()方法，实现了多态。

加：

package zjyange.finish;

public class OpertionAdd extends Operate{

	public Double countResult(){
		Double result = doubleA + doubleB;
		return result;
	}
}

减：

package zjyange.finish;

public class OpertionSub extends Operate{

	public Double countResult(){
		Double result = doubleA - doubleB;
		return result;
	}
}

乘：

package zjyange.finish;

public class OpertionMul extends Operate{
	public Double countResult(){
		Double result = doubleA * doubleB;
		return result;
	}
}

除：

package zjyange.finish;

public class OpertionDiv extends Operate{

	public Double countResult(){
		Double result = doubleA / doubleB;
		return result;
	}
}

接着，最关键的，实现工厂类，通过前台传入的运算符来创建不同的运算方法对象：

package zjyange.finish;

public class OperateFactory {

	//运算工厂类
	public static Operate createOperate(String operate){
		Operate ope = null;
		switch (operate) {
		case "+":
			ope = new OpertionAdd();
			break;
		case "-":
			ope = new OpertionSub();
			break;
		case "*":
			ope = new OpertionMul();
			break;
		case "/":
			ope = new OpertionDiv();
			break;
		default:
			break;
		}
		return ope;
	}
}

最后，我们在主函数中，调用我们的工厂类来创建相应的运算对象，赋值，通过countResult()方法获取结果：

package zjyange.finish;

import java.util.Scanner;

public class OperateCounter {

	public static void main(String[] args) {
		//获取控制台输入的值
		Scanner input = new Scanner(System.in);
		//获取第一个数
		System.out.print("输入第一个数：");
		Double doubleA = input.nextDouble();
		//获取运算符
		System.out.print("输入运算符：");
		String operator = input.next();
		//获取第二个数
		System.out.print("输入第二个数：");
		Double doubleB = input.nextDouble();
		Operate oper;
		oper = OperateFactory.createOperate(operator);
		oper.setDoubleA(doubleA);
		oper.setDoubleB(doubleB);
		Double result = oper.countResult();
		System.out.println("计算结果为：" + result);
	}
}

控制台输出结果：

这时简单工厂模式设计的计算器已经完成了，为了体验一下这种模式的好处，我们来做一下拓展，添加一个求余运算：

package zjyange.finish;

public class OpertionRem extends Operate{

	public Double countResult(){
		Double result = doubleA % doubleB;
		return result;
	}
}

然后在工厂类中添加判断：

package zjyange.finish;

public class OperateFactory {

	//运算工厂类
	public static Operate createOperate(String operate){
		Operate ope = null;
		switch (operate) {
		case "+":
			ope = new OpertionAdd();
			break;
		case "-":
			ope = new OpertionSub();
			break;
		case "*":
			ope = new OpertionMul();
			break;
		case "/":
			ope = new OpertionDiv();
			break;
		case "%":
			ope = new OpertionRem();
			break;
		default:
			break;
		}
		return ope;
	}
}

测试一下，控制台输出：

添加成功，完美！

至此，我们用简单工厂模式完成了我们的计算器，使用简单工厂模式后的计算器代码拓展性强，安全性高，其中教科书般的使用到了java的三大特性：封装/继承/多态。总的来说，简单工厂模式是面向对象很好的诠释。