四则运算问题
传统方案解决四则运算问题分析
解释器模式基本介绍
解释器模式的原理类图
对原理类图的说明-即（解释器模式的角色及职责）
解释器模式来实现四则运算
- 应用实例要求
通过解释器模式来实现四则运算
如：计算a+b-c 的值
2.思路分析和图解（类图）
3.代码实现
package com.sky.interpreter;
import java.util.HashMap;
/**
* 抽象类表达式，通过hashmap 键值对，可以获取到变量的值
*/
public abstract class Expression {
/**
* a + b -c
* 解释公式和数值，key就是公式（表达式） 参数[a,b,c], value 就是具体值
* hashmap {a=10,b=20....}
* @param var
* @return
*/
public abstract int interpreter(HashMap<String,Integer> var);
}
package com.sky.interpreter;
import java.util.HashMap;
/**
* 抽象运算符号解释器，这里，每个运算符号，都只和自己左右两个数字有关系。
* 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类
*/
public class SymbolExpression extends Expression{
protected Expression left;
protected Expression right;
public SymbolExpression(Expression left, Expression right) {
this.left = left;
this.right = right;
}
/**
* 因为 SymbolExpression 是让其子类来实现，因此 interpreter 是一个默认实现
* @param var
* @return
*/
@Override
public int interpreter(HashMap<String, Integer> var) {
return 0; // 这里是一个空实现
}
}
package com.sky.interpreter;
import java.util.HashMap;
/**
* 变量解释器
*/
public class VarExpression extends Expression {
private String key; // key = a ,key = b, key = c
// 构造器
public VarExpression(String key) {
this.key = key;
}
/**
* var 就是 {a=10,b=20....}
* interpreter() 方法 作用：根据变量名称，返回对应值。
* @param var
* @return
*/
@Override
public int interpreter(HashMap<String, Integer> var) {
return var.get(this.key);
}
}
package com.sky.interpreter;
import java.util.HashMap;
public class AddExpression extends SymbolExpression {
public AddExpression(Expression left, Expression right) {
super(left, right);
}
/**
* 处理相加
* var 仍然是 {a=10,b=20....}
* super.left.interpreter(var) : 返回left 表达式对应的值 a=10
* super.right.interpreter(var) : 返回right 表达式对应的值 b=10
* @param var
* @return
*/
@Override
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) + super.right.interpreter(var);
}
}
package com.sky.interpreter;
import java.util.HashMap;
public class SubExpression extends SymbolExpression {
public SubExpression(Expression left, Expression right) {
super(left, right);
}
/**
* 处理相减
* var 仍然是 {a=10,b=20....}
* super.left.interpreter(var) : 返回left 表达式对应的值 a=10
* super.right.interpreter(var) : 返回right 表达式对应的值 b=10
* @param var
* @return
*/
@Override
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) - super.right.interpreter(var);
}
}
package com.sky.interpreter;
import java.util.HashMap;
import java.util.Stack;
/**
* 计算器
*/
public class Calculator {
// 定义表达式
private Expression expression;
// 构造函数传参，并解析
public Calculator(String expStr) {
//安排运算先后顺序
Stack<Expression> stack = new Stack<>();
char[] charArray = expStr.toCharArray(); // [a,+,b]
Expression left = null;
Expression right = null;
// 遍历我们的字符数组,即遍历 [a,+,b] , 针对不同的情况，做不同的处理
for (int i = 0; i < charArray.length; i++) {
switch (charArray[i]) {
case '+':
left = stack.pop(); // 从stack取出left => 'a'
right = new VarExpression(String.valueOf(charArray[++i])); // 取出右表达式 'b'
stack.push(new AddExpression(left, right)); // 然后根据得到 left 和 right 构建 AddExpression 加入到 stack 中
break;
case '-':
left = stack.pop();
right = new VarExpression(String.valueOf(charArray[++i])); //
stack.push(new SubExpression(left, right));
break;
default:
// 如果是一个 var 就创建一个VarExpression对象，并 push 到 stack 中。
stack.push(new VarExpression(String.valueOf(charArray[i])));
break;
}
}
// 当遍历完整个 charArray 数组后，stack 就得到最后的Expression
this.expression = stack.pop();
}
public int run(HashMap<String, Integer> var){
// 最后将表达式a+b 和 var = {a=10,b=20}
// 然后传递给expression的interpreter方法进行解释执行
return this.expression.interpreter(var);
}
}
package com.sky.interpreter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
/**
* 客户端
*/
public class ClientTest {
public static void main(String[] args) throws Exception {
String expStr = getExpStr(); // a+b
HashMap<String, Integer> var = getValue(expStr); // var {a=10,b=20}
Calculator calculator = new Calculator(expStr);
System.out.println("运算结果：" + expStr + "=" + calculator.run(var));
}
// 获得表达式
public static String getExpStr() throws IOException {
System.out.print("请输入表达式：");
return (new BufferedReader(new InputStreamReader(System.in))).readLine();
}
// 获得值映射
public static HashMap<String, Integer> getValue(String expStr) throws IOException{
HashMap<String, Integer> map = new HashMap<>();
for (char ch : expStr.toCharArray()) {
if (ch != '+' && ch != '-') {
if (!map.containsKey(String.valueOf(ch))) {
System.out.print("请输入 " + String.valueOf(ch) + "的值：");
String in = new BufferedReader(new InputStreamReader(System.in)).readLine();
map.put(String.valueOf(ch), Integer.valueOf(in)); // map.put('a',10) 这种样子的
}
}
}
return map;
}
}
请输入表达式：a+b
请输入 a的值：10
请输入 b的值：20
运算结果：a+b=30
解释器模式的注意事项和细节
标签：解释器,right,HashMap,模式,var,interpreter,public,left From： https://www.cnblogs.com/dongyaotou/p/16991472.html