一、面试题
1.1 需求
1、 写出一个简单的计算器
public class TestMain {
public static void main(String[] args) {
System.out.println("====== 简单计算程序 =======");
System.out.println("输入第一个参数:");
Scanner scanner = new Scanner(System.in);
String first = scanner.nextLine();
System.out.println("请输入运算符:");
String per = scanner.nextLine();
System.out.println("请输入第二个参数");
String second = scanner.next();
Double result = 0.0;
switch (per){
case "+":
result = Double.parseDouble(first) + Double.parseDouble(second);
break;
case "-":
result = Double.parseDouble(first) - Double.parseDouble(second);
break;
case "*":
result = Double.parseDouble(first) * Double.parseDouble(second);
break;
case "/":
result = Double.parseDouble(first) / Double.parseDouble(second);
break;
default:
break;
}
System.out.println(result);
}
}
- 运行结果:
1.2、使用工厂方法模式优化
1、抽象角色:运算类
public class Operation {
private double first;
private double second;
public double getFirst() {
return first;
}
public void setFirst(double first) {
this.first = first;
}
public double getSecond() {
return second;
}
public void setSecond(double second) {
this.second = second;
}
public double run(){
return 0.0;
};
}
2、产品角色:相加类;继承自抽象角色
public class AddOperation extends Operation{
@Override
public double run() {
return this.getFirst() + this.getSecond();
}
}
3、产品角色:除法;继承自抽象角色
public class DivisionOperation extends Operation {
@Override
public double run() {
return this.getFirst() / this.getSecond();
}
}
4、产品角色:乘法;继承自抽象角色
public class MultiplicationOperation extends Operation{
@Override
public double run() {
return this.getFirst() * this.getSecond();
}
}
5、产品角色:减法;继承自抽象角色
public class SubOperation extends Operation{
@Override
public double run() {
return this.getFirst() - this.getSecond();
}
}
6、抽象工厂角色:运算类工厂接口
public interface OperationFactory {
Operation getOperation();
}
7、具体工厂角色:加法生产工厂;继承自抽象工厂
public class AddOperationFactory implements OperationFactory {
@Override
public Operation getOperation() {
return new AddOperation();
}
}
8、具体工厂角色:除法生产工厂;继承自抽象工厂
public class DivisionOperationFactory implements OperationFactory {
@Override
public Operation getOperation() {
return new DivisionOperation();
}
}
9、具体工厂角色:乘法生产工厂;继承自抽象工厂
public class MultiplicationOperationFactory implements OperationFactory {
@Override
public Operation getOperation() {
return new MultiplicationOperation();
}
}
10、具体工厂角色:减法生产工厂;继承自抽象工厂
public class SubOperationFactory implements OperationFactory{
@Override
public Operation getOperation() {
return new SubOperation();
}
}
11、新启动类
public class TestMain {
public static void main(String[] args) {
System.out.println("====== 简单计算程序 =======");
System.out.println("输入第一个参数:");
Scanner scanner = new Scanner(System.in);
String first = scanner.nextLine();
System.out.println("请输入第二个参数");
String second = scanner.next();
double result = 0.0;
double one = Double.parseDouble(first);
double two = Double.parseDouble(second);
OperationFactory addOperationFactory = new AddOperationFactory();
Operation addOperation = addOperationFactory.getOperation();
addOperation.setFirst(one);
addOperation.setSecond(two);
System.out.println("加法运算结果 = " + addOperation.run());
System.out.println("=====================================");
OperationFactory subOperationFactory = new SubOperationFactory();
Operation subOperation = subOperationFactory.getOperation();
subOperation.setFirst(one);
subOperation.setSecond(two);
System.out.println("减法运算结果 = " + subOperation.run());
System.out.println("======================================");
OperationFactory multiplicationOperationFactory = new MultiplicationOperationFactory();
Operation multiplicationOperation = multiplicationOperationFactory.getOperation();
multiplicationOperation.setFirst(one);
multiplicationOperation.setSecond(two);
System.out.println("乘法运算结果 = " + multiplicationOperation.run());
OperationFactory divisionOperationFactory = new DivisionOperationFactory();
Operation divisionOperation = divisionOperationFactory.getOperation();
divisionOperation.setFirst(one);
divisionOperation.setSecond(two);
System.out.println("除法运算结果 = " + divisionOperation.run());
}
}
12、测试结果