设计模式：解释器模式解耦不同表达式

作者：日拱一卒程序猿 2023-03-03 08:12:07开发 前端 当有一个语言需要解释执行，设计式解可将该语言中的模式句子表示为一个抽象的语法树，就可以考虑使用解释器模式，解释让程序具有良好的器模扩展性。

一、同表定义

解释器模式（Interpreter Pattern）： 是达式指给定一个语言（表达式），定义它的设计式解文法的一种表示，并定义一个解释器，模式使用该解释器来解释语言中的解释句子（表达式）

应用场景：应用可以将一个需要解释执行的语言中的句子表示为一个抽象语法树，一些重复出现的器模问题可以用一种简单的语言来表达。一个简单语法需要解释的同表场景。这样的达式例子还有：编译器、运算表达式计算、设计式解正则表达式、模式机器人等。解释

二、原理类图

• Context: 是环境角色，含有解释器之外的全局信息。
• AbstractExpression: 抽象表达式，声明一个抽象的解释操作，这个方法为抽象语法树中所有的节点所共享
• TerminalExpression: 为终结符表达式，实现与文法中的终结符相关的解释操作。
• NonTerminalExpression:为非终结符表达式，为文法中的非终结符实现解释操作。
• 说明：输入Context和TerminalExpression信息通过Client输入即可。

三、案例

1、需求

应用解释器模式来实现上面提到的四则运算。

2、代码实现

/**
* 解释器抽象类表达式，通过hashMap键值对，可以获取到变量的值
*/
public abstract class Expression { 
/**
* a + b - c
* 解释公式和数值，key就是公式（表达式） 参数[a,b,c],value就是具体值
* HashMap{ a=10,b=20}
* @param var
*/
public abstract int interpreter(HashMap<String, Integer> var);
}

package com.mayun.study.designpattern.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;
}

/**
*
* @param var 就是{ a=10,b=20}的一个HashMap
* @return 根据变量名称，返回对应值
*/
@Override
public int interpreter(HashMap<String, Integer> var) { 
return var.get(this.key);
}
}

package com.mayun.study.designpattern.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.mayun.study.designpattern.interpreter;

import java.util.HashMap;

/**
* 加法解释器
*/
public class AddExpression extends SymbolExpression { 
public AddExpression(Expression left, Expression right) { 
super(left, right);
}

/**
* 处理相加
* @param var 仍然是{ a=10,b=20}
* @return  返回left表达式对应的值 a =10 与右表达式对于宁的值b=20
*/
@Override
public int interpreter(HashMap<String, Integer> var) { 
return super.left.interpreter(var) + super.right.interpreter(var);
}
}


import java.util.HashMap;

/**
* 减法解释器
*/
public class SubExpression extends SymbolExpression { 
public SubExpression(Expression left, Expression right) { 
super(left, right);
}

/**
* 求出左右两表达式相减的值
* @param var
* @return
*/
@Override
public int interpreter(HashMap<String, Integer> var) { 
return super.left.interpreter(var) - super.right.interpreter(var);
}
}

package com.mayun.study.designpattern.interpreter;

import java.util.HashMap;
import java.util.Stack;

/**
* 计算器类
*/
public class Calculator { 

//定义表达式
private Expression expression;

//构造函数传参，并解析
public Calculator(String expStr) {  // expStr = a+b
//安排运算的先后顺序
Stack<Expression> stack = new Stack<>();
//表达式拆分成字符数组
char[] charArray = expStr.toCharArray();

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
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) { 
//最后将表达式和var绑定 var ={ a=10,b=20},
// 然后传递给expression的interpreter进行解释执行
return this.expression.interpreter(var);
}

}

package com.mayun.study.designpattern.interpreter;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

/**
* 解释器测试类
*/
public class Client { 
public static void main(String[] args) throws IOException { 
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.println("请输入表达式");
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));
}
}
}

return map;
}
}

四、注意事项

• 当有一个语言需要解释执行，可将该语言中的句子表示为一个抽象的语法树，就可以考虑使用解释器模式，让程序具有良好的扩展性。
• 应用场景：编译器、运算表达式计算、正则表达式、机器人等。
• 使用解释器可能带来的问题：解释器模式会引起类膨胀、解释器模式采用递归调用方法，将会导致调试非常复杂，效率可能降低。

责任编辑：武晓燕 来源： 今日头条 设计模式语言

(责任编辑：娱乐)