java23种设计模式-解释器模式

定义

给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子

UML

角色

• 抽象表达式(Expression)：声明一个所有的具体表达式角色都需要实现的抽象接口。该接口提供一个interpret()方法。

• 终结符表达式(Terminal Expression) ：实现了抽象表达式接口，有一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式c=a+b，在里面a和b就是终结符，对应的解析a和b的解释器就是终结符表达式。

• 非终结符表达式(Nonterminal Expression)：文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式c=a+b中，“+"就是非终结符，解析“+”的解释器就是一个非终结符表达式。

• 环境(Context)角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如c=a+b，我们给a赋值2，给b赋值3。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色。

示例

/**
 * desc : 抽象表达式
 * Created by tiantian on 2018/9/29
 */
public abstract class Expression {
    public abstract int interpret(Map<String, Object> map);
}

/**
 * desc : 变量表达式（角色为：终结符表达式，解析各种变量）
 * Created by tiantian on 2018/9/29
 */
public class VarExpression extends Expression {
    
    private String key;

    public VarExpression(String key) {
        this.key = key;
    }
    
    public int interpret(Map<String, Object> map) {
        return (int) map.get(key);
    }
}

/**
 * desc : 抽象符号表达式
 * Created by tiantian on 2018/9/29
 */
public abstract class SymbolExpression extends Expression {
    protected Expression left;
    protected Expression right;

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

/**
 * desc : 加法表达式（角色为：非终结符表达式）
 * Created by tiantian on 2018/9/29
 */
public class AddExpression extends SymbolExpression {
    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }
    
    public int interpret(Map<String, Object> map) {
        return super.left.interpret(map) + super.right.interpret(map);
    }
}

/**
 * desc : 减法表达式（角色为：非终结符表达式）
 * Created by tiantian on 2018/9/29
 */
public class SubExpression extends SymbolExpression {
    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }
    
    public int interpret(Map<String, Object> map) {
        return super.left.interpret(map) - super.right.interpret(map);
    }
}

/**
 * desc : 加减法计算器（使用各种解释器做加减法运算）
 * Created by tiantian on 2018/9/30
 */
public class Calculator {
    
    private Expression expression;

    public Calculator(String exp) {
        char[] charArray = exp.toCharArray();
        Stack<Expression> stack = new Stack();
        
        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 void doCompute(Map<String,Object> param) {
        int res = expression.interpret(param);
        System.out.println("Calculete result is : " + res);
    }

    public static void main(String[] args) {
        Calculator calculator = new Calculator("a-b");
        Map<String,Object> param = new HashMap<>();
        param.put("a", 2);
        param.put("b",3);
        
        calculator.doCompute(param);
    }
}

总结

解释器模式的使用场景不是很多。java中比较好的实现有expression4J。扩展性好，易于实现简单的文法，但是文法复杂时代码不好维护。