【设计模式】简单工厂模式的实现--------java

一．简单工厂模式：
1.初始代码：

public class Test {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		System.out.print("请输入数字A:");
		String A = cin.next();
		System.out.print("请选择运算符号（+、-、*、/）:");
		String B = cin.next();
		System.out.print("请输入数字B:");
		String C = cin.next();
		String D = "";
		if (B.equals("+"))
			D = Integer.parseInt(A) + Integer.parseInt(C) + "";
		if (B.equals("-"))
			D = Integer.parseInt(A) - Integer.parseInt(C) + "";
		if (B.equals("*"))
			D = Integer.parseInt(A) * Integer.parseInt(C) + "";
		if (B.equals("/"))
			D = Integer.parseInt(A) / Integer.parseInt(C) + "";
		System.out.print("结果是：" + D);
	}

}

分析：第一，命名不规范。第二，判断分支很多意味着要判断很多次。第三，没有考虑输入不是数字或者除数为0的情况.

2.改进1：

public class Test {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		try {
			System.out.print("请输入数字A:");
			String strNumberA = cin.next();
			System.out.print("请选择运算符号（+、-、*、/）:");
			String strOperate = cin.next();
			System.out.print("请输入数字B:");
			String strNumberB = cin.next();
			String strResult = "";
			switch (strOperate) {
			case "+":
				strResult = Integer.parseInt(strNumberA) + Integer.parseInt(strNumberB) + "";
				break;
			case "-":
				strResult = Integer.parseInt(strNumberA) - Integer.parseInt(strNumberB) + "";
				break;
			case "*":
				strResult = Integer.parseInt(strNumberA) * Integer.parseInt(strNumberB) + "";
				break;
			case "/":
				if (!strNumberB.equals("0"))
					strResult = Integer.parseInt(strNumberA) / Integer.parseInt(strNumberB) + "";
				else
					strResult="除数不能为0";
				break;
			}
			System.out.print("结果是：" + strResult);
		} catch (Exception e) {
			System.out.print("您的输入有误："+e);
		}
	}

}

分析：没有面向对象，难以复用、拓展、灵活性差。

3.改进2：（封装）

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		try {
			System.out.print("请输入数字A:");
			String strNumberA = cin.next();
			System.out.print("请选择运算符号（+、-、*、/）:");
			String strOperate = cin.next();
			System.out.print("请输入数字B:");
			String strNumberB = cin.next();
			String strResult = "";
			strResult = Operation.GetResult(Double.parseDouble(strNumberA), Double.parseDouble(strNumberB), strOperate)
					+ "";
			System.out.print("结果是：" + strResult);
		} catch (Exception e) {
			System.out.print("您的输入有误：" + e);
		}
	}

}

class Operation {
	public static double GetResult(double numberA, double numberB, String operate) {
		double result = 0;
		switch (operate) {
		case "+":
			result = numberA + numberB;
			break;
		case "-":
			result = numberA - numberB;
			break;
		case "*":
			result = numberA * numberB;
		case "/":
			result = numberA / numberB;
			break;
		}
		return result;
	}
}

分析：修改、拓展不方便。

4.改进3：（简单工厂模式）

import java.util.Scanner;

public class Test {
	public static void main(String[] args) {
		Scanner cin = new Scanner(System.in);
		Operation oper;
		System.out.print("请输入数字A:");
		double numberA = cin.nextDouble();
		System.out.print("请请选择运算符号（+、-、*、/）:");
		oper = OperationFactory.creatOperate(cin.next());
		System.out.print("请输入数字B:");
		double numberB = cin.nextDouble();
		oper.setNumberA(numberA);
		oper.setNumberB(numberB);
		double result = oper.Getresult();
		System.out.println(result);
	}

}

abstract class Operation {
	private double numberA = 0;
	private double numberB = 0;

	public void setNumberA(double numberA) {
		this.numberA = numberA;
	}

	public void setNumberB(double numberB) {
		this.numberB = numberB;
	}

	public double getNumberA() {
		return numberA;
	}

	public double getNumberB() {
		return numberB;
	}

	abstract public double Getresult();
}

class OperationAdd extends Operation {
	public double Getresult() {
		double result = 0;
		result = getNumberA() + getNumberB();
		return result;
	}
}

class OperationSub extends Operation {
	public double Getresult() {
		double result = 0;
		result = getNumberA() - getNumberB();
		return result;
	}
}

class OperationMul extends Operation {
	public double Getresult() {
		double result = 0;
		result = getNumberA() * getNumberB();
		return result;
	}
}

class OperationDiv extends Operation {
	public double Getresult() {
		double result = 0;
		if (getNumberB() == 0)
			System.out.println("除数不能为0！");
		else
			result = getNumberA() / getNumberB();
		return result;
	}
}

class OperationFactory {
	public static Operation creatOperate(String operate) {
		Operation oper = null;
		switch (operate) {
		case "+":
			oper = new OperationAdd();
			break;
		case "-":
			oper = new OperationSub();
			break;
		case "*":
			oper = new OperationMul();
			break;
		case "/":
			oper = new OperationDiv();
			break;
		}
		return oper;
	}
}

优点：工厂类中包含了必要的逻辑判断，根据客户端的选择条件动态实例化相关的类。即客户端不用管应该用哪个类的实例，只需要把“+”丢给工厂，工厂自己就给出了相应的实例，客户端只要去做运算就可以了。
缺点：加功能时要修改类。即不仅对扩展开放，对修改也开放，违背开放封闭原则。