- 定义:给定一门语言,定义它的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子
简言之:是一种按照规定语法进行解析的方案
package interpreter;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;
import java.util.Stack;
/**
* @author hyh
* @create 2021-08-29 10:42
* 抽象一表达式
*/
public abstract class Expresion {
// key 是参数 value 是值 如 a = 3
public abstract int interpreter(HashMap<String, Integer> var);
}
class VarExpresion extends Expresion {
private String key;
public String getKey() {
return key;
}
public VarExpresion(String key) {
this.key = key;
}
@Override
public int interpreter(HashMap<String, Integer> var) {
return var.get(this.key);
}
}
abstract class SymbolExpresion extends Expresion {
public Expresion left;
public Expresion right;
public SymbolExpresion(Expresion left, Expresion right) {
this.left = left;
this.right = right;
}
}
class Add extends SymbolExpresion {
public Add(Expresion left, Expresion right) {
super(left, right);
}
@Override
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) + super.right.interpreter(var);
}
}
class Sub extends SymbolExpresion {
public Sub(Expresion left, Expresion right) {
super(left, right);
}
@Override
public int interpreter(HashMap<String, Integer> var) {
return super.left.interpreter(var) - super.right.interpreter(var);
}
}
class Calculator {
private Expresion e;
public Calculator(String expStr) {
Stack<Expresion> s = new Stack<>();
char[] chars = expStr.toCharArray();
Expresion left;
Expresion right;
for (int i = 0; i < chars.length; i++) {
switch (chars[i]) {
case '+':
left = s.pop();
right = new VarExpresion(String.valueOf(chars[++i]));
s.push(new Add(left, right));
break;
case '-':
left = s.pop();
right = new VarExpresion(String.valueOf(chars[++i]));
s.push(new Sub(left, right));
break;
default:
s.push(new VarExpresion(String.valueOf(chars[i])));
}
}
this.e = s.pop();
}
public int run(HashMap<String, Integer> var) {
return this.e.interpreter(var);
}
}
class Client {
public static void main(String[] args) throws IOException {
String expStr = getExpStr();
//赋值
HashMap<String, Integer> var = getValue(expStr);
Calculator calculator = new Calculator(expStr);
int result = calculator.run(var);
System.out.println(expStr + " 结果:" +result);
}
public static HashMap<String, Integer> getValue(String exprStr)
throws IOException {
HashMap<String, Integer> map = new HashMap<>(16);
//解析有几个参数要传递
for (char ch : exprStr.toCharArray()) {
if (ch != '+' && ch != '-') {
//解决重复参数的问题
if (!map.containsKey(String.valueOf(ch))) {
String in = (new BufferedReader(new
InputStreamReader(System.in))).readLine();
map.put(String.valueOf(ch), Integer.valueOf(in));
}
}
}
return map;
}
private static String getExpStr() throws IOException {
System.out.print("请输入表达式:");
return (new BufferedReader(new InputStreamReader(System.in)))
.readLine();
}
}
输出:
请输入表达式:a+b+c
2
2
2
a+b+c 结果:6