解释器模式

这是设计模式最后一篇，迟迟没有写。听到这个名字可能会想到解释型语言，学习编译倒也可以参考一下这个。这个在实际工作中用的很少，直接上实现加减乘除的代码吧

public class Interpreter {
    interface Expression {
        int interpret(Context context);
    }

    //终结符表达式(Terminal Expression)
    static class Constant implements Expression {
        private int i;

        public Constant(int i) {
            this.i = i;
        }

        @Override
        public int interpret(Context context) {
            return i;
        }
    }

    static class Variable implements Expression {
        @Override
        public int interpret(Context context) {
            return context.LookupValue(this);
        }
    }

    //非终结符表达式(Nonterminal Expression)
    static class Add implements Expression {
        private Expression left, right;

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

        @Override
        public int interpret(Context context) {
            return left.interpret(context) + right.interpret(context);
        }
    }

    static class Sub implements Expression {
        private Expression left, right;

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

        @Override
        public int interpret(Context context) {
            return left.interpret(context) - right.interpret(context);
        }
    }

    static class Mul implements Expression {
        private Expression left, right;

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

        @Override
        public int interpret(Context context) {
            return left.interpret(context) * right.interpret(context);
        }
    }

    static class Div implements Expression {
        private Expression left, right;

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

        @Override
        public int interpret(Context context) {
            return left.interpret(context) / right.interpret(context);
        }
    }

    //环境(Context)角色，保存一些值
    static class Context {
        private Map valueMap = new HashMap<>();

        public void addValue(Variable x, int y) {
            valueMap.put(x, y);
        }

        public int LookupValue(Variable x) {
            return (int) valueMap.get(x);
        }
    }

    public static void main(String[] args) {
        Context context = new Context();
        Variable a = new Variable();
        Variable b = new Variable();
        Constant c = new Constant(15000);
        context.addValue(a, 14);
        context.addValue(b, 10000);

        Expression expression =  new Add(new Sub(c, b), a);
        System.out.println("Result = " + expression.interpret(context));
    }
}
输出：
Result = 5014

核心就两个：环境对象、表达式。写完了，很多地方思考的应该都不是太清楚。以后可能要持续更新，好的东西都是打磨出来的。等自己再上一个台阶也会想想当时的思维，写下来也有个记录还是挺好的。

觉得容易理解的话面向对象的23种设计模式点这里