标签:ase 加法 int toc line abstract 分享 rar cal
模型公式,输入一个公式,然后输入其中的参数,然后运算出结果
抽象表达式类
public abstract class Expression{
// 解析数值,key是参数,value是数字
public abstract int interpreter(HashMap<String, Integer> var);
}
变量解析器,根据此,可以获得保存在map中的键值对
public class VarExpress extends Expression{
private String key;
public VarExpression(String _key){
this.key = _key;
}
// map取
public int interpreter(HashMap<String, Integer> var){
return var.get(this.key);
}
}
抽象运算符号解析器
public abstract class SymbolExpression extends Expression{
// 左数值
protected Expression left;
// 右数值
protected Expression right;
// 初始化
public SymbolExpression(Expression _left, Expression _right){
this.left = _left;
this.right = _right;
}
}
对加法进行解析
public class AddExpression extends SymbolExpression{
public AddExpression(Expression _left, Expression _right){
super(_left, _right);
}
// 进行相加
public int interpreter(HashMap<String, Integer> var){
// 取得,两边的变量都保存在HashMap表中,根据left和right变量,进行相加
return super.left.interpreter(var) + super.right.interpreter(var);
}
// 进行相减
public int interpreter(HashMap<String,Integer> var){
return super.left.interpreter(var) - super.right.interpreter(var);
}
}
再次对解析器进行封装,此为公式
public class Calculator{
// 定义表达式
private Expression expression;
// 传参
public Calculator(String expStr){
// 用于先后顺序
Stack stack = new Stack();
// 将表达式拆分
char[] charArray = expStr.toCharArray();
// 运算
Expression left = null;
Expression right = null;
for(int i = 0; i < charArray.length; i++){
switch(charArray[i]){
case ‘+‘
// 出栈
left = stack.pop();
right = new VarExpression(String.valueOf(chrArray[++i]));
// 将结果入栈
stack.push(new AddExpression(left, right));
break;
case ‘-‘
// 放入栈中
left = stack.pop();
right = new VarExpression(String.valueOf(charArray[++i]));
stack.push(new SubExpression(left,right));
break;
default:
stack.push(new VarExpression(String.value(charArray[i])));
}
}
// 运算结果抛出
this.expression = stack.pop();
}
// 运算
public int run(HashMap<String, Integer> var){
return this.expression.interpreter(var);
}
}
在上方中,完成的是对表达式的输入
最后场景
public class Client{
public static void main(String[] args) throws IOException{
String expStr = getExpStr();
// 赋值
HashMap<String, Integer> var = getValue(expStr);
Calculator cal = new Calculator(expStr);
System.out.println("运算");
}
// 获得表达式
public static String getExpStr() throws IOException{
// 新建一个缓冲区,从缓冲区中读取数据
return (new BufferedReader(new InputStreamReader(System.in))).readLine();
}
// 获得值映射
public static HashMap<String, Integer> getValue(String expStr) throws IOException{
HashMap<String, Integer> map = new HashMap<String, Integer>();
// 解析
for(char ch:exprStr.toCharArray()){
if(ch != ‘+‘ && != ‘-‘){
if(!map.containsKey(String.valueOf(ch))){
// 从缓冲区中,读取整行
String in = (new BufferReader(new InputStreamReader(System.in))).readLine();
}
}
}
return map;
}
}
解释器模式不难,核心思想在于构建语法树,进行运算的时候,进行递归调用。
具体做法是创建几个解释器,在创建一个解释器封装类,在解释器封装类中完成语法树的构建。然后在场景类中完成递归调用。
标签:ase 加法 int toc line abstract 分享 rar cal
原文地址:https://www.cnblogs.com/melovemingming/p/10317818.html