解释器模式

解释器模式

介绍

解释器模式：给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。（行为型模式）

解释器模式uml图一般如下：

• AbstractExpression 抽象解释器

     具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和NonterminalExpression完成。

• TerminalExpression终结符表达式

    实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。具体到我们例子就是VarExpression类，表达式中的每个终结符都在堆栈中产生了一个VarExpression对象。

• NonterminalExpression 非终结符表达式

    文法中的每条规则对应于一个非终结表达式，具体到我们的例子就是加减法规则分别对应到AddExpression和SubExpression两个类。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。

• Context 环境角色

    具体到我们的例子中是采用HashMap代替。

正则表达式就是使用了解释器模式
解释器模式在实际的系统开发中使用的非常少，因为它会引起效率、性能以及维护等问题，一般在大中型的框架型项目能够找到它的身影，比如一些数据分析工具、报表设计工具、科学计算工具等等，若你确实遇到“一种特定类型的问题发生的频率足够高”的情况，准备使用解释器模式时，可以考虑一下Expression4J、MESP（Math Expression String Parser）、Jep等开源的解析工具包，功能都异常强大，而且非常容易使用，效率也还不错，实现大多数的数学运算完全没有问题.

优缺点

优点

解释器是一个简单语法分析工具，它最显著的优点就是扩展性，修改语法规则只要修改相应的非终结符表达式就可以了，若扩展语法，则只要增加非终结符类就可以了。

缺点

• 每个语法都要产生一个非终结符表达式，语法规则比较复杂时，就可能产生大量的类文件，为维护带来了非常多的麻烦。

• 解释器模式采用递归调用方法，如果要排查一个语法错误，要一个一个断点的调试下去，会很麻烦。

• 解释器模式使用了大量的循环和递归，特别是用于解析复杂、冗长的语法时，效率会很低。

DEMO

设计一个四则运算（这里只写了加减），可以应用各种模型公式。uml图如下：

代码如下：

抽象解释器

package factory.pattern.interpreter;

import java.util.HashMap;

/**
 * Created by FK on 2017/8/11.
 */
public abstract class Expression {
   public abstract int interpreter(HashMap<String, Integer> var);
}

抽象非终结符表达式，定义文法中的规则

package factory.pattern.interpreter;

/**
 * Created by FK on 2017/8/11.
 */
public abstract class SymbolExpression extends Expression {
    protected Expression left;
    protected Expression right;

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

具体的非终结符表达式

package factory.pattern.interpreter;

import java.util.HashMap;

/**
 * Created by FK on 2017/8/11.
 */
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);
    }
}

具体的非终结符表达式

package factory.pattern.interpreter;

import java.util.HashMap;

/**
 * Created by FK on 2017/8/11.
 */
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);
    }
}

终结符表达式

package factory.pattern.interpreter;

import java.util.HashMap;

/**
 * Created by FK on 2017/8/11.
 */
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);
    }
}

Calcuator的作用是封装，根据迪米特原则，Client只与直接的朋友Calcuator交流，与其他类没关系。

package factory.pattern.interpreter;

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

/**
 * Created by FK on 2017/8/11.
 */
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);
    }
}

测试

package factory.pattern.interpreter;

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

/**
 * Created by FK on 2017/8/11.
 */
public class Test {
    public static void main(String[] args) throws IOException {
        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.println("输入表达式");
        return (new BufferedReader((new InputStreamReader(System.in)))).readLine();
    }

    public static HashMap<String, Integer> getValue(String expreStr) throws IOException {
        HashMap<String, Integer> map = new HashMap<>();
        for(char ch : expreStr.toCharArray()){
            if(ch != '+' && ch != '-'){
                if(!map.containsKey(String.valueOf(ch))){
                    System.out.print("请输入"+ch+"的值:");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch),Integer.valueOf(in));
                }
            }
        }
        return map;
    }

}

输出结果

输入表达式
a+b-c
请输入a的值:100
请输入b的值:20
请输入c的值:40
运算结果为：a+b-c=80