还记得刚入门C语言的时候经常要写一些加加减减的程序来练练手。好吧,既然学了新语言,那就用新语言来写个简单的计算器吧!
public class Calculator {
public static void main(String[] args) {
int a,b;
Scanner scanner = new Scanner(System.in);
System.out.print("输入第一个数:");
a = scanner.nextInt();
System.out.print("输入第二个数:");
b = scanner.nextInt();
System.out.print("输入运算符:");
char op = scanner.next().charAt(0);
System.out.print("结果:");
switch (op) {
case '+':
System.out.println(a + b);
break;
case '-':
System.out.println(a - b);
break;
case '*':
System.out.println(a * b);
break;
case '/':
if (b != 0)
System.out.println(a / b);
else
System.out.println("除数不能为0!");
break;
default:
System.out.println("没有该运算符号!");
break;
}
}
}
好吧,写到这里,相信大家都会觉得好low…,确实是这样。程序只是简单实现了加减乘除,却没有体现面向对象的思想,也没有任何的扩展性。那么,我们就引入一个新的设计模式——工厂模式。工厂模式的好处在于能够负责实现创建所有实例的内部逻辑,给程序带来更大的可扩展性和尽量少的修改量。那么且看工厂模式是如何实现上述的计算器的。
简单工厂模式
我们可以先看看简单工厂模式的UML图:
图中角色主要分为以下三类:
简单工厂类:这是简单工厂模式的核心,由它负责创建所有的类的内部逻辑。当然工厂类必须能够被外界调用,创建所需要的产品对象。
抽象产品(运算类):简单工厂模式所创建的所有对象的父类。
具体产品(加减法类):简单工厂所创建的具体实例对象,这些具体的产品往往都拥有共同的父类。
先来看一个运算类:
public abstract class Operation { //抽象类,运算类
public int numberA, numberB; //运算的两个数据
abstract int getResult(); //抽象方法,返回运算结果
}
class AddOperation extends Operation { //加法类
@Override
int getResult() {
return numberA + numberB;
}
}
class SubOperation extends Operation { //减法类
@Override
int getResult() {
return numberA - numberB;
}
}
class MulOperation extends Operation { //乘法类
@Override
int getResult() {
return numberA * numberB;
}
}
class DivOperation extends Operation { //除法类
@Override
int getResult() {
if (numberB == 0) {
throw new ArithmeticException("除数不能为0");
}
return numberA / numberB;
}
}
有了运算符类了,那么也要有一个生产运算符的工厂吧:
public class OperationFactory { //运算符加工厂
public static Operation createOperate(char operate) { //生产运算类
Operation op = null;
switch (operate) {
case '+':
op = new AddOperation();
break;
case '-':
op = new SubOperation();
break;
case '*':
op = new MulOperation();
break;
case '/':
op = new DivOperation();
break;
}
return op;
}
}
再写一个计算器测试类:
public class Calculator {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
System.out.print("输入运算符:");
char operation = scanner.next().charAt(0);
Operation op = OperationFactory.createOperate(operation); //通过工厂生产一个运算类
System.out.print("输入第一个数字:");
op.numberA = scanner.nextInt();
System.out.print("输入第二个数字:");
op.numberB = scanner.nextInt();
try {
System.out.print("结果:" + op.getResult()); //输出运算结果
} catch (ArithmeticException e) {
System.out.print(e.getMessage());
}
}
}
看,一个简单的工厂模式就出现了。它实现了整个计算器程序的逻辑和业务上的分离。在工厂方法模式中,工厂方法用来创建各种运算符,同时还向客户端隐藏了哪种具体产品类将被实例化这一细节。而且工厂模式有良好的扩展性比如,现在我们需要再添加一种运算方式,“两个数的平方和”,那么我们只需在添加一个具体的运算类,并在运算符工厂中添加多一个case便可实现:
class squareOperation extends Operation {
@Override
int getResult() {
return numberA * numberA + numberB * numberB;
}
}
当然,简单工厂模式也有其缺点。我们将其优点和缺点列举如下:
优点:
1、用户想创建一个对象,只要知道其名称就可以从工厂中获取对象。
2、扩展性高,如果想增加一个产品,只要扩展一个具体产品类就可以。
3、屏蔽产品的具体实现,用户只关心产品的接口。
缺点:
每次增加一个产品时,都需要增加一个具体类和对象实现工厂,使得程序中出现大量的类,在一定程度上增加系统的复杂度。