25. 23种经典设计模式-39-解释器模式

以你之姓@ 2024-04-17 14:55 53阅读 0赞

## 1. 解释器模式(Interrepeter Pattern) ##

> Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language. (给定一门语言, 定义它的文法表示, 并定义一个解释器, 改解释器使用该表示来解释语言中的句子)

### 1.1 解释器模式-核心思想 ###

定义一种新的语言，并指定语法解析方式.

### 1.2 解释器模式-类图 ###

解析器有四个角色:

*  AbstractExpression: 抽象解析器， 定义抽象方法. 只有一个抽象方法
 *  TerminalExpression: 终结符表达式， 通常一个解析模式中只有一个终结符表达式
 *  NonterminalExpression: 非终结符表达式.
 *  Context: 上下文, 包含解析器之外的一些全局信息.

![format_png][]

### 1.3 解释器模式-优缺点 ###

*  优点: 扩展性号, 修改语法规则只需要修改相应的非终结符表达式即可
 *  缺点:
    
     *  解析器模式会引起类膨胀
     *  解析器模式采用递归调用方式, 效率较低
     *  理解困难

### 1.4 解释器模式-适用场景 ###

*  一个简单语法需要解释的场景
 *  重复发生的问题可以适用解释器模式

### 1.5 注意事项 ###

*  项目开发中，尽量不要适用解释器模式.
 *  java 开发中如果需要用到解析器模式时，可以参考Expression4J, Jep, MESP(Math Expression String Parser)等开源的解析工具包，每必重复造轮子

## 2. 解析器模式-应用示例 ##

解析器模式应用太少, 笔者直接从书上摘抄了一个加减法的示例

### 2.1 类图 ###

![format_png 1][]

### 2.2 抽象表达式-Expression ###

// 抽象表达式类
    public abstract class Expression { 
    
        // 解析公式和数值, 其中var中的key值是公式中的参数, value是具体的数值
        public abstract int interpreter(HashMap<String, Integer> var);
    }

### 2.3 终结符表达式-VarExpression ###

// 变量解析器
    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(key);
        }
    }

### 2.4 符号表达式-SymbolExpression ###

// 抽象符号解析器
    public abstract class SymbolExpression extends Expression { 
    
        protected Expression left;
    
        protected Expression right;
    
        public SymbolExpression(Expression left, Expression right) { 
            this.left = left;
            this.right = right;
        }
    
    }

### 2.5 加法表达式-AddExpression ###

// 加法解析器
    public class AddExpression extends SymbolExpression { 
        public AddExpression(Expression left, Expression right) { 
            super(left, right);
        }
    
        @Override
        public int interpreter(HashMap<String, Integer> var) { 
            return super.left.interpreter(var) + super.right.interpreter(var);
        }
    }

### 2.6 减法表达式-SubExpression ###

// 减法解析器
    public class SubExpression extends SymbolExpression { 
        public SubExpression(Expression left, Expression right) { 
            super(left, right);
        }
    
        @Override
        public int interpreter(HashMap<String, Integer> var) { 
            return super.left.interpreter(var) - super.right.interpreter(var);
        }
    }

### 2.7 计算器-Calculator ###

public class Calculator { 
    
        // 表达式
        private Expression expression;
    
        public Calculator(String expStr) { 
    
            // 定义一个栈, 安排运算符的先后有顺序
            Stack<Expression> stack = new Stack<>();
    
            // 表达式拆分为字符数组
            char[] charArray = expStr.toCharArray();
    
            // 运算
            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])));
                }
            }
    
            // 把计算结果抛出来
            this.expression =  stack.pop();
    
        }
    
        // 开始运算
        public int run(HashMap<String, Integer> var) { 
            return this.expression.interpreter(var);
        }
    }

### 2.8 测试 ###

@Test
        public void test(){ 
    
            // 表达式
            String expStr = "a+b-c";
    
            // 变量值
            HashMap<String, Integer> map = new HashMap<>();
            map.put("a", 10);
            map.put("b", 5);
            map.put("c", 1);
    
            // 计算器
            Calculator calculator = new Calculator(expStr);
    
            // 计算
            int result = calculator.run(map);
    
            System.out.println(expStr + "=" + result);
        }

### 2.9 测试输出 ###

a+b-c=14

[format_png]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3pvbmdmMDUwNC9ibG9nLWltYWdlcy9tYXN0ZXIvaW1hZ2VzL2Rlc2lnbi1wYXJ0dGVybi9sZHAtaW50ZXJyZXRlci0wMS5wbmc?x-oss-process=image/format,png
[format_png 1]: https://imgconvert.csdnimg.cn/aHR0cHM6Ly9yYXcuZ2l0aHVidXNlcmNvbnRlbnQuY29tL3pvbmdmMDUwNC9ibG9nLWltYWdlcy9tYXN0ZXIvaW1hZ2VzL2Rlc2lnbi1wYXJ0dGVybi9sZHAtaW50ZXJyZXRlci0wMi5wbmc?x-oss-process=image/format,png