Ejemplo de modo de intérprete del modo de comportamiento

Revise el patrón de diseño hoy y vea el patrón de intérprete. Pensando en un problema que encontré antes.

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

Anteriormente, se resolvía mediante componentes tripartitos. Si desea implementar una solución extensible y fácil de interactuar por su cuenta. No pensé en una buena manera antes.

De hecho, se puede solucionar encapsulando dos capas en el modo de intérprete.

Pero mi ejemplo de intérprete usa otro ejemplo más simple como ejemplo. Lo anterior es solo un pensamiento.

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

El intérprete generalmente consta de varias partes.

1. Contexto (entorno): encapsula la información global del intérprete, todos los intérpretes específicos necesitan acceder al contexto.

2. AbstractExpression: una clase o interfaz abstracta. Todos los intérpretes específicos implementan el método de interpretación de la ejecución de la declaración.

3. TerminalExpression (expresión terminal). Una clase de intérprete que implementa operaciones relacionadas con terminadores gramaticales. La expresión terminal debe implementarse o instanciarse, porque significa el final de la expresión

4. NonTerminalExpression (expresión no terminal): una clase que implementa diferentes reglas o símbolos gramaticales. Cada gramática debería crear una clase.

Ejemplo de código de implementación:

1. Interfaz de expresión:

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

    public float interpret();
}

2. Expresión de terminador. (En este ejemplo, un valor numérico)

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


    private float number;

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

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

3. Expresiones de símbolos no terminales. En este ejemplo, las dos reglas de suma y resta se toman como ejemplos.

/**
 * 操作符解释器:加法
 */
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. Escriba un fragmento de código para implementar el árbol de sintaxis creando una buena clase.

/**
 * 通过解释器类实现语法树
 */
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 +"));
    }
}

Un código de modo de intérprete simple está completo.