大话设计模式——简单工厂模式
--参考自《大话设计模式》
需求
现在有一个需求，实现一个简单的计算器
对于一般的初学者来说可能会这么实现：
public class calculate {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
System.out.println("请输入数字A:");
String numberA = cin.next();
System.out.println("请输入运算符号(+,-,*,/):");
char op = cin.next().charAt(0);
System.out.println("请输入数字B:");
String numberB = cin.next();
String rst = null;
if(op == '+'){
rst = String.valueOf(Integer.parseInt(numberA)+Integer.parseInt(numberB));
}
if(op == '-'){
rst = String.valueOf(Integer.parseInt(numberA)-Integer.parseInt(numberB));
}
if(op == '*'){
rst = String.valueOf(Integer.parseInt(numberA)*Integer.parseInt(numberB));
}
if(op == '/'){
rst = String.valueOf(Integer.parseInt(numberA)/Integer.parseInt(numberB));
}
System.out.println("结果是： " + rst);
}
}
修改后的版本：
public class calculate2 {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
try {
System.out.println("请输入数字A:");
String numberA = cin.next();
System.out.println("请输入运算符号(+,-,*,/):");
char op = cin.next().charAt(0);
System.out.println("请输入数字B:");
String numberB = cin.next();
String rst = null;
switch (op){
case '+':rst = String.valueOf(Integer.parseInt(numberA)+Integer.parseInt(numberB));break;
case '-':rst = String.valueOf(Integer.parseInt(numberA)-Integer.parseInt(numberB));break;
case '*':rst = String.valueOf(Integer.parseInt(numberA)*Integer.parseInt(numberB));break;
case '/':
if(!numberB.equals("0")){
rst = String.valueOf(Integer.parseInt(numberA)/Integer.parseInt(numberB));
}else{
rst = "除数不能为0！";
}
break;
}
System.out.println("结果是： " + rst);
}catch (Exception e){
System.out.println("您的输入有错："+e.getMessage());
}
}
}
已经改的不错了，但是这种代码相对来说，可维护性和可扩展性低，如果现在需要重新写一个计算器，那么想一想我们的代码能不能复用呢？
那....Crtl+C和Crtl+V大法呀，多香呀。
有人说初级程序员的工作就是Crtl+C和Crtl+V，其实这是非常不好的编码习惯，想想当你的项目中，重复代码很多的时候，这就是一场灾难，有一个需求发生变化，那么你想想你得修改多少代码？
如果我们能将业务逻辑和客户端代码分开，让他们的耦合度下降，这样才能达到容易维护和扩展的目的。
我们将代码进行修改：
Operation类：
public class Operation {
public static double getResult(double numberA,double numberB,String operate){
double rst = 0.0;
switch (operate.charAt(0)){
case '+':
rst = numberA + numberB;
break;
case '-':
rst = numberA - numberB;
break;
case '*':
rst = numberA * numberB;
break;
case '/':
rst = numberA / numberB;
break;
}
return rst;
}
}
客户端逻辑代码：
public class testOperation {
public static void main(String[] args) {
Scanner cin = new Scanner(System.in);
try{
System.out.println("请输入数字A:");
String numberA = cin.next();
System.out.println("请输入运算符号(+,-,*,/):");
String op = null;
op = cin.next();
System.out.println("请输入数字B:");
String numberB = cin.next();
System.out.println("结果是： "+ Operation.getResult(Double.parseDouble(numberA),Double.parseDouble(numberB),op));
}catch (Exception e){
System.out.println("您的输入有误："+e.getMessage());
}
}
}
将业务逻辑和界面逻辑分离开，感觉维护性高多了，卧槽，牛逼呀。
问题又来了，如果现在要增加一个sqrt运算的需求怎么办，如何改？
只要修改Operation类，然后再switch里加一个分支就行了。
就增加了一个功能，就要让其他加减乘除所有的功能都参与运算，如果不小心改到加法运算里了怎么办？如果这是一个公司的计算工资的业务代码，如果参与维护的那个员工有私心，在完成sqrt运算的时候偷偷改了别的代码，改变了自己工资的计算方式，那岂不是风险太大了？
如果我们引入继承和多态，修改一个功能的时候不影响其他功能，这样风险就小很多。
operactionClass计算类：
public abstract class operationClass {
private double number_a = 0;
private double number_b = 0;
public abstract double getResult();
public operationClass() {
}
public double getNumber_a() {
return number_a;
}
public void setNumber_a(double number_a) {
this.number_a = number_a;
}
public double getNumber_b() {
return number_b;
}
public void setNumber_b(double number_b) {
this.number_b = number_b;
}
}
加减乘除类都继承自运算类：
public class operationAdd extends operationClass {
@Override
public double getResult() {
return getNumber_a() + getNumber_b();
}
}
public class operationSub extends operationClass {
@Override
public double getResult() {
return getNumber_a() + getNumber_b();
}
}
public class operationMul extends operationClass{
@Override
public double getResult() {
return getNumber_a() + getNumber_b();
}
}
public class operationDiv extends operationClass{
@Override
public double getResult() throws Exception {
if(getNumber_b() == 0){
throw new Exception("被除数不能为0！");
}
return getNumber_a() + getNumber_b();
}
}
实现了一部分，但是问题来了，我们如果让计算机知道我希望用哪一个算法呢？
简单工厂类##
现在就是到底要实例化谁？将来不会增加实例化的对象，比如增加sqrt功能，这是很容易变化的地方，应该用一个单独的类来做创造实例化的过程，这就是工厂。
简单工厂运算类：
public class operationFactory {
public static operationClass createOperate(String op){
operationClass operation = null;
switch (op.charAt(0)){
case '+':
operation = new operationAdd();
break;
case '-':
operation = new operationSub();
break;
case '*':
operation = new operationMul();
break;
case '/':
operation = new operationDiv();
break;
}
return operation;
}
}
只需要提供符号，就能生产出合适的实例化对象，通过多态，返回父类的方式实现了计算机的结果。
客户端代码实现 测试：
public class test {
@Test
public void testFactory() throws Exception {
operationClass oper;
oper = operationFactory.createOperate("+");
oper.setNumber_a(11);
oper.setNumber_b(22);
System.out.println(oper.getResult());
}
}
通过工厂模式，如果我们要增加复杂的运算，比如开根号，平方运算，只要增加相应的子类并且改造工厂的分支就可以了。这样就实现了业务逻辑和界面逻辑分离，功能模块之间的耦合也降低了。