设计模式解释器模式(InterpreterPattern)

核心模块：抽象表达符、非终结表达符、终结表达符、环境类

所有代码请访问：git@code.aliyun.com:289804201/PatternLearn.git

使用场景：正则表达式，自定义语言，计算器；

优点：易于扩展，增加新的符号只用增加新的表达式即可；

缺点：复杂的文法难以维护， 存在大量循环和递归操作，复杂的句子，速度很慢 ；

注意：

1，每一个非终结符号都对应一个非终结表达式；

/**
 * Created by tory on 2017/12/7.
 * //解释器模式，
 * 1，来解释该语言中的句子
 * 使用场景：1，正则表达式，2，计算器，3，自定义语言
 * 2，每一个非终结符都有一个具体的非终结表达式与之相对
 */
public class InterpreterPattern {
    public static void main(String[] args) {
        String express = "3 + 2 - 5 / 6";
        int val = new Calculator().build(express).compute();
        System.out.println("out->"+val);
    }

}

//Context 环境类
class Calculator {
    //环境类里面要么是map要么是stack之类的存放表达式的容器
    Expression expression = null;

    Calculator build(String expStr) {
        String[] expArry = expStr.split(" ");
        Stack<Expression> stack = new Stack<>();
        Expression left = null;
        Expression right = null;
        for (int iLoop = 0; iLoop < expArry.length; iLoop++) {
            switch (expArry[iLoop]) {
                //处理各个非终结符，都有一个对应的非终结表达式
                case "+":
                    left = stack.pop();
                    right = new ValExpression(Integer.parseInt(expArry[++iLoop]));
                    stack.push(new AddExpression(left, right));
                    break;
                case "-":
                    left = stack.pop();
                    right = new ValExpression(Integer.parseInt(expArry[++iLoop]));
                    stack.push(new SubExpression(left, right));
                    break;
                case "*":
                    left = stack.pop();
                    right = new ValExpression(Integer.parseInt(expArry[++iLoop]));
                    stack.push(new MulExpression(left, right));
                    break;
                case "/":
                    left = stack.pop();
                    right = new ValExpression(Integer.parseInt(expArry[++iLoop]));
                    stack.push(new DivExpression(left, right));
                    break;
                case "%":
                    left = stack.pop();
                    right = new ValExpression(Integer.parseInt(expArry[++iLoop]));
                    stack.push(new ModExpression(left, right));
                    break;
                default:
                    stack.push(new ValExpression(Integer.parseInt(expArry[iLoop])));
                    break;
            }
        }
        expression = stack.pop();
        return this;
    }

    int compute() {
        if (null != expression) {
            return expression.interpreter();
        }

        return Integer.MIN_VALUE;
    }
}

//Expression抽象表示符
interface Expression {
    int interpreter();
}

//SymbleExpression符号表示符，非终结表示符
abstract class SymbleExpression implements Expression {
    Expression left;
    Expression right;

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

//TerminalExpression 终结表示符
class ValExpression implements Expression {
    int val;

    ValExpression(int val) {
        this.val = val;
    }

    @Override
    public int interpreter() {
        return val;
    }
}

//具体的非终结表示符+
class AddExpression extends SymbleExpression {
    AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() + right.interpreter();
    }
}

//具体的非终结表示符-
class SubExpression extends SymbleExpression {
    SubExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() - right.interpreter();
    }
}

//具体的非终结表示符*
class MulExpression extends SymbleExpression {
    MulExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() * right.interpreter();
    }
}

//具体的非终结表示符/
class DivExpression extends SymbleExpression {
    DivExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() / right.interpreter();
    }
}

//具体的非终结表示符%
class ModExpression extends SymbleExpression {
    ModExpression(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() % right.interpreter();
    }
}

内容打印

Hello World!

out->6