设计模式（十六）解释器模式

落日映苍穹つ 2022-06-18 04:44 161阅读 0赞

解释器模式是一种行为型模式，它的主要作用是用一种方式来实现对表达式或文法的处理。我们可以使用解释器模式处理语言的解析，在设计计算机语言的时候解释器模式很有用处。

解释器模式可能需要用到一点编译原理的知识。不过我自己编译原理的内容都忘光了，所以这里不做编译原理的任何介绍了。直接来看代码吧。我们来做一个不含括号的四则运算的解释器。

解释器模式首先需要一个表达式接口，其中有一个方法用于解析表达式的值。

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

之后来考虑一些具体的表达式。首先是常量表达式，这个很简单，直接返回常量的值即可。

class Constant implements Expression { 
        private int i;
    
        public Constant(int i) {
            this.i = i;
        }
    
        @Override
        public int interpret(Context context) {
            return i;
        }
    }

然后是变量，变量的值保存在上下文中，在编译领域也可以叫做符号表之类的，反正都是一个意思。

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

上下文，或者叫符号表，是保存变量值的地方。我们在Java中可以简单的使用Map来当做符号表。

public class Context {
        private HashMap<Variable, Integer> map = new HashMap<>();
    
        public void putValue(Variable name, int value) {
            map.put(name, value);
        }
    
        public int getValue(Variable name) {
            return map.get(name);
        }
    }

然后是加减乘除四种表达式。这个非常简单，没啥说的吧。

class Add implements Expression { 
        private Expression a, b;
    
        public Add(Expression a, Expression b) {
            this.a = a;
            this.b = b;
        }
    
        @Override
        public int interpret(Context context) {
            return a.interpret(context) + b.interpret(context);
        }
    }
    
    class Sub implements Expression { 
        private Expression a, b;
    
        public Sub(Expression a, Expression b) {
            this.a = a;
            this.b = b;
        }
    
        @Override
        public int interpret(Context context) {
            return a.interpret(context) - b.interpret(context);
        }
    }
    
    class Mul implements Expression { 
        private Expression a, b;
    
        public Mul(Expression a, Expression b) {
            this.a = a;
            this.b = b;
        }
    
        @Override
        public int interpret(Context context) {
            return a.interpret(context) * b.interpret(context);
        }
    }
    
    class Div implements Expression { 
        private Expression a, b;
    
        public Div(Expression a, Expression b) {
            this.a = a;
            this.b = b;
        }
    
        @Override
        public int interpret(Context context) {
            return a.interpret(context) / b.interpret(context);
        }
    }

这些类都准备好之后，我们就可以测试一下解释器模式了。我们手动创建一个表达式，然后调用它的`interpret()`方法对其求值。之后，表达式就会如我们所愿的给出结果。

public void run() {
            Variable a = new Variable();
            Variable b = new Variable();
            Context context = new Context();
            context.putValue(a, 3);
            context.putValue(b, 4);
    
            //a+b*(a-b)+2
            Expression expression = new Add(a, new Add(new Mul(b, new Sub(a, b)), new Constant(2)));
            System.out.println("a+b*(a-b)+2=" + expression.interpret(context));
        }

当然，这只是一个非常简单的小例子，因为`new Add(a, new Add(new Mul(b, new Sub(a, b)), new Constant(2)))`这个表达式树是我们手动创建的。如果我们希望更加实用的话，就需要自己编写程序，解析字符串，然后转换为抽象语法树。这就属于编译原理的话题了。

参考资料：[设计模式(行为型)之解释器模式(Interpreter Pattern)][Interpreter Pattern]

[Interpreter Pattern]: http://blog.csdn.net/yanbober/article/details/45537601