行为模式之解释器模式 示例

今天覆习设计模式看到解释器模式。想到之前我碰到过的一个问题。

问题：前后端多条件的解析。
例：某字符串token开始于“a” 且包含“b” 或长度等于10

之前是通过三方的组件解决的。如果要自己实现一个可扩展、易交互的方案。之前没想到什么好办法。

其实可以用解释器模式封装两层来解决。

但我的解释器示例以另一个更简单的例子做一个举例。上面的仅是一个思考。

问题：波兰表示法。运算符末尾添加操作数的方式
例：1 2 + 代表1+2的运算。 3 4 + 5 - 6 + 代表3+4-5+6的运算

解释器一般有几部分组成。

1、Context(环境)：封装解释器的全局信息，所有具体的解释器都需访问Context.

2、AbstractExpression(抽象表达式)：一个抽象类或接口。声明执行的解释方法，由所有具体的解释器实现。

3、TerminalExpression(终结符表达式)。一种解释器类，实现与语法终结符相关的操作。终结符表达式必须被实现或示例化，因为它表示表达式的结尾

4、NonTerminalExpression(非终结符表达式)：实现语法的不同规则或符号的类。每一个语法都应该创建一个类。

实现代码示例：

1、表达式接口：

/**
 * 表达式接口
 */
public interface Expression {

    public float interpret();
}

2、终结符表达式。（在本例中为数值）

/**
 * 数值表达式
 */
public class NumberExpression implements Expression{


    private float number;

    public NumberExpression(float number){
        this.number = number;
    }

    @Override
    public float interpret() {
        return number;
    }
}

3、非终结符表达式。本例中以加法、减法两个规则为例

/**
 * 操作符解释器:加法
 */
public class PlusExpression implements Expression{


    Expression left;
    Expression right;
    public PlusExpression(Expression left, Expression right){

        this.left = left;
        this.right = right;
    }
    @Override
    public float interpret() {
        return this.left.interpret() + this.right.interpret();
    }
}

/**
 * 操作符解释器：减法
 */
public class MinusExpression implements Expression{


    Expression left;
    Expression right;
    public MinusExpression(Expression left, Expression right){

        this.left = left;
        this.right = right;
    }
    @Override
    public float interpret() {
        return this.left.interpret() - this.right.interpret();
    }
}

4、写一段代码通过建立好的类来实现语法树。

/**
 * 通过解释器类实现语法树
 */
public class Evaluator {

    public float evaluator(String expression){

        Stack<Expression> stack = new Stack<>();
        float result = 0;
        for (String token : expression.split(" ")){

            if(isOperator(token)){
                Expression exp = null;
                if(token.equals("+")){
                   exp = stack.push(new PlusExpression(stack.pop(), stack.pop()));
                }else if(token.equals("-")){
                   exp = stack.push(new MinusExpression(stack.pop(),stack.pop()));
                }

                if(exp != null){
                    result = exp.interpret();
                    stack.push(new NumberExpression(result));
                }
            }

            if(isNumber(token)){
                stack.push(new NumberExpression(Float.parseFloat(token)));
            }
        }
        return result;
    }

    private boolean isOperator(String token){
        if(token.equals("+") || token.equals("-"))
            return true;
        return false;
    }

    private boolean isNumber(String token){
        try {
            float v = Float.parseFloat(token);
            return true;
        }catch (Exception e){
            return false;
        }
    }

    public static void main(String[] args) {

        Evaluator evaluator = new Evaluator();
        System.out.println(evaluator.evaluator("2 3 +"));
        System.out.println(evaluator.evaluator("2 3 + 5 - 6 +"));
    }
}

一个简单的解释器模式代码完成了。