设计模式（十九）行为型模式---解释器模式（interpreter）

解释器模式简介

• 解释器模式（interpreter pattern）是给定一个语言表达式，定义它的文法表示，并定义一个解释器，解释器使用该标识来解释语言中的句子。例如：a+b+c=d，这种就是一种”语言“的句子。

什么是抽象语法树？

抽象语法树（AbstractSyntaxTree）：是源代码语法结构的一种抽象表示，它以树状的形式表现编程语言的语法结构，树上的每个节点都表示源代码中的一种结构。

例如：1+2+3+4-5的语法树

结构

• 1.抽象表达式角色（Abstract Expression）：定义解释器的接口，约定解释器的解释操作，主要包含有解释方法interpret（）；
• 2.终结符表达式角色（Terminal Expression）：抽象表达式的子类，用来实现文法中与终结符线管操作，文法中每一个终结符都有一个具体总结表达式与之对应。
• 3.非终结表达式角色（Nonterminal Expression）:抽象表达式子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都应于一个非终结符表达式。
• 4.环境角色（Context）：通常包含各个解释器需要的数据或者公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取值。
• 5.客户端（Client）：主要任务是将需要分析的句子或者表达式 转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，也可以通过环境角色间接访问解释器的解释方法。

UML图

具体实现

例子：用解释器模式，实现加减法运算。

UML图

代码实现

• 抽象表达式

package com.xxliao.pattern.behavioral.interpreter.demo;

import java.util.HashMap;

/**
 * @description  定义抽象表达式
 * @author  xxliao
 * @date  2024/5/26 22:49
 */
public abstract class Expression {

	/**
	 * @description  解释公式和数值，key就是公式（表达式）参数[a,b,c]，value就是对应的具体值
	 *
	 * HashMap<String,Integer> var : {a=10,b=20}
	 *
	 * @author  xxliao
	 * @date  2024/5/26 22:51
	 */
	public abstract int interpreter(HashMap<String, Integer> var);
}

• 终结表达式

package com.xxliao.pattern.behavioral.interpreter.demo;

import java.util.HashMap;

/**
 * @description  值表达式
 *
 * --终结表达式
 *
 * @author  xxliao
 * @date  2024/5/26 22:56
 */
public class VarExpression extends Expression {

	private String key; 

	public VarExpression(String key) {
		this.key = key;
	}

	@Override
	public int interpreter(HashMap<String, Integer> var) {
		return var.get(this.key);
	}
}

• 非终结表达式

package com.xxliao.pattern.behavioral.interpreter.demo;

import java.util.HashMap;

/**
 * @description 抽象运算符号解析器 这里，每个运算符合都只和自己左右两个数字有关系，
 * 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类
 *
 * -- 非终结表达式。
 *
 * @author  xxliao
 * @date  2024/5/26 22:53
 */
public class SymbolExpression extends Expression {

	protected Expression left;
	protected Expression right;

	public SymbolExpression(Expression left, Expression right) {
		this.left = left;
		this.right = right;
	}

	/**
	 * @description  由子类来实现
	 * @author  xxliao
	 * @date  2024/5/26 22:54
	 */
	@Override
	public int interpreter(HashMap<String, Integer> var) {
		// TODO Auto-generated method stub
		return 0;
	}
}

• 加法表达式（是非终结表达式的子类）

package com.xxliao.pattern.behavioral.interpreter.demo;

import java.util.HashMap;

/**
 * @description  加法表达式
 * @author  xxliao
 * @date  2024/5/26 22:54
 */
public class AddExpression extends SymbolExpression  {

	public AddExpression(Expression left, Expression right) {
		super(left, right);
	}

	public int interpreter(HashMap<String, Integer> var) {
		return super.left.interpreter(var) + super.right.interpreter(var);
	}
}

• 减法表达式（是非终结表达式的子类）

package com.xxliao.pattern.behavioral.interpreter.demo;

import java.util.HashMap;

/**
 * @description  减法表达式
 * @author  xxliao
 * @date  2024/5/26 22:55
 */
public class SubExpression extends SymbolExpression {

	public SubExpression(Expression left, Expression right) {
		super(left, right);
	}

	public int interpreter(HashMap<String, Integer> var) {
		return super.left.interpreter(var) - super.right.interpreter(var);
	}
}

• 环境角色（context）

package com.xxliao.pattern.behavioral.interpreter.demo;

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

/**
 * @description  context角色
 * @author  xxliao
 * @date  2024/5/27 15:05
 */
public class Calculator {

	// 定义表达式
	private Expression expression;

	// 构造函数传参，并解析
	public Calculator(String expStr) {
		// 安排运算先后顺序
		Stack<Expression> stack = new Stack<>();
		char[] charArray = expStr.toCharArray();// {a,+,b,-,c}

		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(charArray[++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.valueOf(charArray[i]))); // 创建值表达式
				break;
			}
		}
		this.expression = stack.pop();
	}

	/**
	 * @description  计算方法
	 * @author  xxliao
	 * @date  2024/5/27 15:06
	 */
	public int run(HashMap<String, Integer> var) {
		return this.expression.interpreter(var);
	}
}

• 测试客户端

package com.xxliao.pattern.behavioral.interpreter.demo;

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

/**
 * @description  测试客户端
 * @author  xxliao
 * @date  2024/5/27 15:08
 */
public class ClientTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		String expStr = getExpStr(); 
		HashMap<String, Integer> var = getValue(expStr);
		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));
				}
			}
		}

		return map;
	}
}

• 测试结果