设计模式之解释器模式_解释器模式是结构性设计模式吗-CSDN博客

本文链接：https://blog.csdn.net/qq_45747519/article/details/121003870

解释器模式

1.简要概述

解释器模式是一种用得比较少的设计模式，属于行为型设计模式。
解释器模式提供了一种解释语言的语法或表达式的方式，该模式定义了一个表达式接口，通过该接口解释一个特定的上下文。
解释器模式用于描述如何构成一个简单的语言解释器，主要用于使用面向对象语言开发的编译器和解释器设计。
解释器模式的核心思想就是为给定的语言创建解释器，然后对语言中的语法进行分析，定义出它的文法的一种表示，最后通过解释器来解释运行语言中的句子。

2.模式结构

👉通常由一个上下文环境类( 负责定义一些解释器之外的一些全局信息 )，一个抽象表达式类( 负责声明一个抽象的解释操作,供语法树中的所有节点使用 )，一个终结符表达式类( 负责实现与语法中的终结符相关的解释操作 )，一个非终结符表达式类( 负责实现与语法中的非终结符相关的解释操作 )，一个客户类( `负责对表达式类进行调用,完成语言的解释操作)共同组成。

请添加图片描述

3.实现代码

举例 💡 ：用解释器模式实现四则运算表达式的解释执行

表达式抽象类

public abstract class Expression {
	
	// 解释器抽象方法
	public abstract int interpret(HashMap<String, Integer> valueMap); 
}

变量解释器(终结符表达式类)

public class VarExpression extends Expression{

	private String key;
	
	public VarExpression(String key) {
		this.key = key;
	}
	
	// 变量取值解释器
	@Override
	public int interpret(HashMap<String, Integer> valueMap) {
		
		return valueMap.get(key);
	}
}

加法运算符解释器(非终结符表达式类)

public class AddExpression extends Expression{

	private Expression var1;
	
	private Expression var2;
	
	public AddExpression(Expression var1, Expression var2) {
		this.var1 = var1;
		this.var2 = var2;
	}
	
	// 加法逻辑解释器
	@Override
	public int interpret(HashMap<String, Integer> valueMap) {
		
		return var1.interpret(valueMap) + var2.interpret(valueMap);
	}
}

减法运算符解释器(非终结符表达式类)

public class SubExpression extends Expression{

	private Expression var1;
	
	private Expression var2;
	
	public SubExpression(Expression var1, Expression var2) {
		this.var1 = var1;
		this.var2 = var2;
	}
	
	// 减法逻辑解释器
	@Override
	public int interpret(HashMap<String, Integer> valueMap) {
		
		return var1.interpret(valueMap) - var2.interpret(valueMap);
	}
}

计算器类(上下文环境类)

public class Calculator {
	
	private Expression expression;
	
	public Calculator(String express) {
		Stack<Expression> stack = new Stack<>();
		char[] symbols = express.toCharArray();
		
		// 表达式解析执行
		Expression var1 = null;
		Expression var2 = null;
		for (int i = 0; i < symbols.length; i++) {
			switch (symbols[i]) {
			case '+':
				var1 = stack.pop();
				var2 = new VarExpression(String.valueOf(symbols[++i]));
				stack.push(new AddExpression(var1, var2));
				break;
			case '-':
				var1 = stack.pop();
				var2 = new VarExpression(String.valueOf(symbols[++i]));
				stack.push(new SubExpression(var1, var2));
				break;
			default:
				stack.push(new VarExpression(String.valueOf(symbols[i])));
				break;
			}
		}
		
		this.expression = stack.pop();
	}
	
	public int excute(HashMap<String, Integer> valueMap) {
		
		return expression.interpret(valueMap);
	}
}

客户类

// 测试客户端
public class CompanyClient{
    public static void main(String[] args) {
        // 定义一个表达式
        String express = "a+b-c";

        // 创建计算器对表达式进行解析
        Calculator calculator = new Calculator(express);
        
        // 计算指定数据的运算结果
        HashMap<String, Integer> valueMap = getValue(express);
        System.out.println(express + "=" + calculator.excute(valueMap));
    }
    
    public static HashMap<String, Integer> getValue(String express){
        HashMap<String, Integer> result = new HashMap<>();
        
        Scanner scanner = new Scanner(System.in);
        
        for (char c : express.toCharArray()) {
        	if(c != '+' && c != '-') {
        		System.out.println("请输入变量" + c + "的值：");
        		int value = scanner.nextInt();
        		
        		result.put(String.valueOf(c), Integer.valueOf(value));
        	}
		}
        
        return result;
    }
}