注：示例来自《大话设计模式》
如果让我们手写一个计算器程序 可能是下面这样
package designpattern;
import java.util.Scanner;
public class Program {
public static void main(String[] args) {
try {
System.out.println("请输入数字A:");
String strNumberA = new Scanner(System.in).nextLine();
System.out.println("请选择运算符号(+、-、*、/):");
String strOperate = new Scanner(System.in).nextLine();
System.out.println("请输入数字B:");
String strNumberB = new Scanner(System.in).nextLine();
String strResult = "";
switch (strOperate) {
case "+":
strResult = String.valueOf(Double.parseDouble(strNumberA) + Double.parseDouble(strNumberB));
break;
case "-":
strResult = String.valueOf(Double.parseDouble(strNumberA) - Double.parseDouble(strNumberB));
break;
case "*":
strResult = String.valueOf(Double.parseDouble(strNumberA) * Double.parseDouble(strNumberB));
break;
case "/":
if (!"0".equals(strNumberB))
strResult = String.valueOf(Double.parseDouble(strNumberA) / Double.parseDouble(strNumberB));
else
throw new RuntimeException("除数不能为0");
break;
}
System.out.println("结果是:" + strResult);
} catch (Exception e) {
System.out.println("您的输入有错:");
e.printStackTrace();
}
}
}
上面的代码实现计算器没有问题 可是上面的代码不容易维护 不容易扩展 更不容易复用 耦合度太高 下面运用面向对象的封装降低耦合度 让业务逻辑与界面逻辑分开
Operation运算类
package designpattern;
public class Operation {
public static double GetResult(double numberA, double numberB, String operate){
double result = 0d;
switch (operate) {
case "+":
result = numberA + numberB;
break;
case "-":
result = numberA - numberB;
break;
case "*":
result = numberA * numberB;
break;
case "/":
result = numberA / numberB;
break;
}
return result;
}
}
客户端类
package designpattern;
import java.util.Scanner;
public class Program {
public static void main(String[] args) {
try {
System.out.println("请输入数字A:");
String strNumberA = new Scanner(System.in).nextLine();
System.out.println("请选择运算符号(+、-、*、/):");
String strOperate = new Scanner(System.in).nextLine();
System.out.println("请输入数字B:");
String strNumberB = new Scanner(System.in).nextLine();
String strResult = "";
strResult = String.valueOf(Operation.GetResult(Double.parseDouble(strNumberA),
Double.parseDouble(strNumberB),strOperate));
System.out.println("结果是:" + strResult);
} catch (Exception e) {
System.out.println("您的输入有错:");
e.printStackTrace();
}
}
}
上面的代码我们应该把加减乘除等运算分离 修改其中一个不影响另外的几个 下面我们运用继承和多态 看看如何实现
Operation运算类
package designpattern;
public abstract class Operation {
private double _numberA = 0;
private double _numberB = 0;
public double get_numberA() {
return _numberA;
}
public void set_numberA(double _numberA) {
this._numberA = _numberA;
}
public double get_numberB() {
return _numberB;
}
public void set_numberB(double _numberB) {
this._numberB = _numberB;
}
public abstract double getResult();
}
加法类
package designpattern;
public class OperationAdd extends Operation {
@Override
public double getResult() {
double result = 0;
result = get_numberA() + get_numberB();
return result;
}
}
减乘除类一样的 这里省略
下面是实例化对象的问题 将来有可能会增加实例化的对象 这是很容易变化的地方 应该用一个单独的类来处理创造实例的过程 这就是工厂 下面看看这个类如何写
简单运算工厂类
package designpattern;
public class OperationFactory {
public static Operation createOperate(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;
}
}
只要输入运算符号 工厂就实例化出合适的对象 通过多态 返回父类的方式实现了计算器的结果
客户端代码
package designpattern;
import java.util.Scanner;
public class Program {
public static void main(String[] args) {
try {
System.out.println("请输入数字A:");
String strNumberA = new Scanner(System.in).nextLine();
System.out.println("请选择运算符号(+、-、*、/):");
String strOperate = new Scanner(System.in).nextLine();
System.out.println("请输入数字B:");
String strNumberB = new Scanner(System.in).nextLine();
String strResult = "";
Operation oper;
oper = OperationFactory.createOperate(strOperate);
oper.set_numberA(Double.parseDouble(strNumberA));
oper.set_numberB(Double.parseDouble(strNumberB));
strResult = String.valueOf(oper.getResult());
System.out.println("结果是:" + strResult);
} catch (Exception e) {
System.out.println("您的输入有错:");
e.printStackTrace();
}
}
}
如果有一天需要更改加法运算 只需要改对应的加法类
优点：客户端与后台实现了分离 容易维护 容易扩展 容易复用
缺点：如果需要增加运算 需要增加相应的子类及修改运算类工厂switch里面的代码 这是耦合性很高的表现