【Java设计模式】二十三、解释器模式

骑猪看日落 2024-04-23 15:46 64阅读 0赞

#### 文章目录 ####

*  1、解释器模式
 *  2、案例

## 1、解释器模式 ##

计算一个表达式的值，比如1+2-3+4-7，单纯的定义方法或函数很难适配所有，因为数值和运算符可以有无数种组合。

//用于n个整数相加
    public static int add(Integer ... arr) {
        
    	int sum = 0;
    	for (Integer i : arr) {
        
    		sum += i;
    	}
    	return sum;
    }

如果把运算符和数字看作一个个节点，逐个去读取和解析，则可适配所有。即定义一个解释器去解释表达式。解释器模式常用于SQL解析、符号处理引擎。主要角色：

*  抽象表达式类：接口，定义解释操作，包含一个interpret方法
 *  终结符表达式类：下例中的变量或者值
 *  非终结表达式类：下例中的运算符（加法、减法）
 *  环境角色：传递被解释器共享的数据，解释器从这里获取值

## 2、案例 ##

![在这里插入图片描述][120cecac47a34cf5ba9264a6cdbc4060.png]

定义抽象表达式类，定义一个解释的方法，聚合环境类对象

//抽象角色AbstractExpression
    public abstract class AbstractExpression {
        
        public abstract int interpret(Context context);
    }

定义终结符表达式（变量类）

//终结符表达式角色 变量表达式
    public class Variable extends AbstractExpression {
        
    
        private String name;
    
        public Variable(String name) {
        
            this.name = name;
        }
    
        @Override
        public int interpret(Context ctx) {
        
            return ctx.getValue(this);
        }
    
        @Override
        public String toString() {
        
            return name;
        }
    }

//终结符表达式角色
    public class Value extends AbstractExpression {
        
    
        private int value;  
    
        public Value(int value) {
        
            this.value = value;
        }
    
        @Override
        public int interpret(Context context) {
        
            return value;
        }
    
        @Override
        public String toString() {
        
            return new Integer(value).toString();
        }
    }

将左边表达式和右边表达式的结果相加

//非终结符表达式角色  加法表达式
    public class Plus extends AbstractExpression {
        
    
        private AbstractExpression left;  //+号左边的表达式
        private AbstractExpression right;  // +号右边的表达式
    
        public Plus(AbstractExpression left, AbstractExpression right) {
        
            this.left = left;
            this.right = right;
        }
    
        @Override
        public int interpret(Context context) {
        
        	//将左边表达式和右边表达式的结果相加
            return left.interpret(context) + right.interpret(context);
        }
    
        @Override
        public String toString() {
        
            return "(" + left.toString() + " + " + right.toString() + ")";
        }
    }

//非终结符表达式角色 减法表达式
    public class Minus extends AbstractExpression {
        
        private AbstractExpression left;
        private AbstractExpression right;
    
        public Minus(AbstractExpression left, AbstractExpression right) {
        
            this.left = left;
            this.right = right;
        }
    
        @Override
        public int interpret(Context context) {
        
    	    //将左边表达式和右边表达式的结果相减
            return left.interpret(context) - right.interpret(context);
        }
    
        @Override
        public String toString() {
        
            return "(" + left.toString() + " - " + right.toString() + ")";
        }
    }

环境角色类，定义一个Map集合，用来存储变量及对应的值

//环境类
    public class Context {
        
        private Map<Variable, Integer> map = new HashMap<Variable, Integer>();
    	
    	//添加变量的功能
        public void assign(Variable var, Integer value) {
        
            map.put(var, value);
        }
    
        public int getValue(Variable var) {
        
            Integer value = map.get(var);
            return value;
        }
    }

测试类：

//测试类
    public class Client {
        
        public static void main(String[] args) {
        
        	//创建环境对象
            Context context = new Context();
    
            Variable a = new Variable("a");
            Variable b = new Variable("b");
            Variable c = new Variable("c");
            Variable d = new Variable("d");
            Variable e = new Variable("e");
            //Value v = new Value(1);
    
            context.assign(a, 1);
            context.assign(b, 2);
            context.assign(c, 3);
            context.assign(d, 4);
            context.assign(e, 5);
    		//获取抽象语法树对象
            AbstractExpression expression = new Minus(new Plus(new Plus(new Plus(a, b), c), d), e);
    		//解释（计算）
            System.out.println(expression + "= " + expression.interpret(context));
        }
    }

[120cecac47a34cf5ba9264a6cdbc4060.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/23/bb621b5a72324f52bc5faa25f1979ff1.png