简单工厂模式

以简单的计算器实现为例。

一、普通方法实现简单计算器。

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
double NumA;
double NumB;
String sign;
NumA = scan.nextDouble();
NumB = scan.nextDouble();
sign = scan.next();
double result = 0;
switch (sign) {
case "+":
result = NumA + NumB;
break;
case "-":
result = NumA - NumB;
break;
case "*":
result = NumA * NumB;
break;
case "/":
if (NumB != 0) {
result = NumA / NumB;
} else {
System.out.println("除数不能为0");
}
break;
default:
break;
}
//return result;
}

二、用面向对象的思想去改进代码--业务逻辑与界面逻辑分开，使他们的耦合度下降；

Operation预算类：

public static double Operation(double NumA, double NumB, String operate) {

double result = 0;
switch (operate) {
case "+":
result = NumA + NumB;
break;
case "-":
result = NumA - NumB;
break;
case "*":
result = NumA * NumB;
break;
case "/":
if (NumB != 0) {
result = NumA / NumB;
} else {
System.out.println("除数不能为0");
}
break;
default:
break;
}
return result;
}

客户端代码：

public static void main(String[] args) {
Scanner scan = new Scanner(System.in);
double NumA;
double NumB;
String sign;
NumA = scan.nextDouble();
NumB = scan.nextDouble();
sign = scan.next();
System.out.println(Operation(NumA, NumB, sign));
}

上面的代码虽然实现了面向对象中的封装，但是如果要添加一种计算方式（如：开根运算）还不是很方便，添加一个case的话，其余的运算也得参与编译，使代码存在被二次修改的风险。

三、用继承和多态进一步解耦；

1.封装运算类；

public class Operation {
private double NumA;
private double NumB;
public double getNumA() {
return NumA;
}
public void setNumA(double numA) {
NumA = numA;
}
public double getNumB() {
return NumB;
}
public void setNumB(double numB) {
NumB = numB;
}
public double GetResult() {

double result  = 0;
return result;
}
}

2.加减乘除类（继承运算类）；

public class AddOperation extends Operation{

@Override
public double GetResult() {

double result = 0;
result = getNumA() + getNumB() ;
return result;
}

public class SubOperation extends Operation {

@Override
public double GetResult() {
double result = 0;
result = getNumA() - getNumB();
return result;
}

public class MulOperation extends Operation{

@Override
public double GetResult() {

double result = 0;
result = getNumA() * getNumB();
return result;

}

}

public class DivOperation extends Operation{

@Override
public double GetResult() {
double result = 0;
if (getNumB()==0)
try {
throw new Exception("除数不能为0;");
} catch (Exception e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
result = getNumA() / getNumB();
return result;

}

}

3.简单工厂类（用一个单独的类来创造容易变化的地方的实例过程），用多态确定选择的运算。

public class OperationFactory {

public static Operation createOperation(String operate) {

Operation oper = null;
switch (operate) {
case "+":
oper = new AddOperation();
break;
case "-":
oper = new SubOperation();
break;
case "*":
oper = new MulOperation();
break;
case "/":
oper = new DivOperation();
break;
default:
break;
}
return oper;
}
}

客户端代码

public class Main {
public static void main(String[] args) {
Operation oper;
oper = OperationFactory.createOperation("+");
oper.setNumA(2);
oper.setNumB(3);
double result = oper.GetResult();
System.out.println(result);
}

}

经过上述修改的简单计算器运用面向对象思想，实现封装、继承、多态等特性，达到了代码可复用、可扩展、灵活性好的目的。

四、UML图