设计模式-简单工厂

未使用设计模式的计算机程序

package SimpleFactoryPattern_1;
import java.util.Scanner;

/**
 * 没有使用设计模式的计算器程序
 * @author Lenovo
 *
 */
public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		try{
			System.out.println("输入第一个数字");
			int a = scan.nextInt();
			System.out.println("输入进行的操作");
			String operator = scan.next();			
			System.out.println("输入第二个数字");
			int b = scan.nextInt();
			String result = "";
			switch (operator) {
			case "+":
				result += a + b;
				break;
			case "-":
				result += a - b;
				break;
			case "*":
				result += a * b;
				break;
			case "/":
				if(b == 0){
					result += "你输入第二个的数不能为0";
				}else{
					result += a / b;
				}
				break;
			default:
				break;
			}
			System.out.println("运算的结果是：" + result);
		}catch(Exception e){
			System.out.println("输入有误");
		}finally{
			scan.close();
		}
	}
}

如果要增加一个平方根方法，那么我们就要去修改这个Main程序，对于服务端和客户端而言，有时候我们希望客户端的修改是不频的。

将业务代码和界面分类

package SimpleFactoryPattern_2;

public class Operation {
	protected int num1;
	protected int num2;
	public Operation(int num1,int num2){
		this.num1 = num1;
		this.num2 = num2;
	}
	protected String getResult(String operator) {
		String result = "";
		switch (operator) {
		case "+":
			result += num1 + num2;
			break;
		case "-":
			result += num1 - num2;
			break;
		case "*":
			result += num1 * num2;
			break;
		case "/":
			if(num2 == 0){
				result += "你输入第二个的数不能为0";
			}else{
				result += num1 / num2;
			}
			break;
		default:
			break;
		}
		return result;
	}
}

package SimpleFactoryPattern_2;

import java.util.Scanner;

/**
 * 引入面向对象的思想
 * 将业务逻辑和界面分离,这时候就可以将业务逻辑的部分复用，比如现在不用控制台程序，改成windows界面程序也一样的可以复用
 * @author Lenovo
 *
 */
public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		try{
			System.out.println("输入第一个数字");
			int a = scan.nextInt();
			System.out.println("输入进行的操作");
			String operator = scan.next();			
			System.out.println("输入第二个数字");
			int b = scan.nextInt();
			String result = new Operation(a,b).getResult(operator);
			System.out.println("计算结果为：" + result);
		}catch(Exception e){
			System.out.println("你的输入有误");
		}finally{
			scan.close();
		}
	}
}

如果要增加一个平方根的计算方法，那么就需要将已有的业务逻辑暴露给开发人员，这可能导致将原本是正确的业务逻辑改错。
这里介绍一种设计模式，简单工厂模式。

简单工厂

1、先将运算方法抽象：我们希望运算类有2个功能，一个是存放运算的操作数，第二个是返回运算的结果。

package SimpleFactoryPattern_3;

public abstract class Operation {
	protected int num1;
	protected int num2;
	public Operation(int num1,int num2){
		this.num1 = num1;
		this.num2 = num2;
	}
	public abstract int getResult() throws Exception;
}

2、具体的运算实现类

package SimpleFactoryPattern_3;
public class OperationAdd extends Operation {
	public OperationAdd(int num1, int num2) {
		super(num1, num2);
	}
	@Override
	public int getResult() {
		return this.num1 + this.num2;
	}
}

package SimpleFactoryPattern_3;
public class OperationDev extends Operation{
	public OperationDev(int num1, int num2) {
		super(num1, num2);
	}
	@Override
	public int getResult() throws Exception {
		if(num2 == 0){
			throw new Exception("除数不能为0");
		}else{
			return num1/num2;
		}
	}
}

package SimpleFactoryPattern_3;
public class OperationMul extends Operation {
	public OperationMul(int num1, int num2) {
		super(num1, num2);
	}
	@Override
	public int getResult() {
		return this.num1 * num2;
	}
}

package SimpleFactoryPattern_3;
public class OperationSub extends Operation {
	public OperationSub(int num1, int num2) {
		super(num1, num2);
	}
	@Override
	public int getResult() {
		return num1 - num2;
	}
}

3、生成具体操作的工厂

在这里插入代码片package SimpleFactoryPattern_3;
/**
 * 用来生成对应操作的简单工厂
 * @author Lenovo
 *
 */
public class OperactionFactory {
	public static Operation createOperation(int num1,int num2,String operator){
		switch (operator) {
		case "+":
			return new OperationAdd(num1, num2);
		case "-":
			return new OperationSub(num1, num2);
		case "*":
			return new OperationMul(num1, num2);
		case "/":
			return new OperationDev(num1, num2);
		default:
			break;
		}
		return null;		
	}
}

4、客户端Main

package SimpleFactoryPattern_3;

/**
 * 使用简单工厂模式，当我们希望再添加一个求a的b次方的方法的时候，就只添加一个OperationPower并继承Operation抽象类。
 * 这种方式的好处在于可以分工进行开发，比如让这些同事写加的部分，让另外某些同时写减的部分，同时对于后来的同事，如果希望
 * 添加一个求幂的方法，那么也不需要吧已经写的加的部分和减的部分给他们。若按版本二的做法，我们还是需要把整个Operation类给对方
 * 一旦对方由于某些原因改错了某些代码，那么就导致了原来原本可以使用的模块而变的不可用。
 */
import java.util.Scanner;
public class Main {
	public static void main(String[] args) {
		Scanner scan = new Scanner(System.in);
		try{
			System.out.println("输入第一个数字");
			int a = scan.nextInt();
			System.out.println("输入进行的操作");
			String operator = scan.next();			
			System.out.println("输入第二个数字");
			int b = scan.nextInt();
			int result = OperactionFactory.createOperation(a, b, operator).getResult();
			System.out.println("计算结果为：" + result);
		}catch(Exception e){
			System.out.println("你的输入有误");
		}finally{
			scan.close();
		}		
	}
}

总结

使用简单工厂模式，通过简单工厂生成对应的逻辑类，这里主要用多态的思想，一方面能够将客户端界面和业务逻辑分离，另一方面，在模块化开发的时候，不需要将已写好的业务逻辑暴露给开发人员。