定义
给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。
为了解释一种语言,而为语言创建的解释器。
类型
行为型
适用场景
①、某个特定类型问题发生频率足够高。
优缺点
优点:
①、语法由很多类表示,容易改变及扩展此“语言”。
缺点:
①、当语法规则数目太多时,增加了系统复杂度。
代码实现
案例,利用栈来自定义一套加法和乘法的语法,来解释某个字符串。
首先定义一个解释器的接口
public interface Interpreter {
int interpreter();
}
创建一个加法的解释器
public class AddInterpreter implements Interpreter {
private Interpreter firstExpression, secondExpression;
public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpreter() {
return this.firstExpression.interpreter() + this.secondExpression.interpreter();
}
@Override
public String toString() {
return "+";
}
}
再创建一个乘法的解释器
public class MultiInterpreter implements Interpreter {
private Interpreter firstExpression, secondExpression;
public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
this.firstExpression = firstExpression;
this.secondExpression = secondExpression;
}
@Override
public int interpreter() {
return this.firstExpression.interpreter() * this.secondExpression.interpreter();
}
@Override
public String toString() {
return "*";
}
}
创建一个数字转换的解释器。
public class NumberInterpreter implements Interpreter {
private int number;
public NumberInterpreter(int number) {
this.number = number;
}
public NumberInterpreter(String number) {
this.number = Integer.parseInt(number);
}
@Override
public int interpreter() {
return this.number;
}
}
创建一个获取当前解释器类型的工具类
public class OperatorUtil {
/**
* 判断是否可操作(+ 或者 *)
*/
public static boolean isOperator(String symbol) {
return (symbol.equals("+") || symbol.equals("*"));
}
public static Interpreter getExpressionObject(Interpreter firstExpression, Interpreter secondExpression, String symbol) {
if (symbol.equals("+")) {
return new AddInterpreter(firstExpression, secondExpression);
} else if (symbol.equals("*")) {
return new MultiInterpreter(firstExpression, secondExpression);
}
return null;
}
}
最后开始进行表达式的解析
public class CustomerExpressionParser {
/**
* 声明一个栈
*/
private Stack<Interpreter> stack = new Stack<Interpreter>();
public int parse(String str) {
String[] strArray = str.split(" ");
for (String symbol : strArray) {
// 判断当前字符是否可操作
if (!OperatorUtil.isOperator(symbol)) {
Interpreter numberExpression = new NumberInterpreter(symbol);
// 入栈
stack.push(numberExpression);
System.out.println(String.format("入栈: %d", numberExpression.interpreter()));
} else {
// 是运算符,可以计算
Interpreter firstExpression = stack.pop();
Interpreter secondExpression = stack.pop();
System.out.println(String.format("出栈: %d 和 %d", firstExpression.interpreter(), secondExpression.interpreter()));
Interpreter operator = OperatorUtil.getExpressionObject(firstExpression, secondExpression, symbol);
System.out.println(String.format("应用运算符: %s", operator));
assert operator != null;
int result = operator.interpreter();
NumberInterpreter resultExpression = new NumberInterpreter(result);
stack.push(resultExpression);
System.out.println(String.format("阶段结果入栈: %d", resultExpression.interpreter()));
}
}
return stack.pop().interpreter();
}
}
编写测试类
public class MainTest {
public static void main(String[] args) {
String str = "6 100 11 + *";
CustomerExpressionParser expressionParser = new CustomerExpressionParser();
int result = expressionParser.parse(str);
System.out.println("解释器计算结果: " + result);
}
}
输出结果:
到此,自定义解释器就完成了,在平时开发中,基本上不用自己创建解释器。只是学习和理解这种设计模式。
相关源码
1. Jdk中的Pattern正则表达式。
2. Spring中的EL表达式。