设计模式（15）——解释器(Interpreter)

た入场券 2022-08-08 06:46 148阅读 0赞

### 解释器模式是什么？ ###

解释器模式简单来说就是用语法规则来解释一种语言。需要定义语法，以及一个解释器。

![Image 1][]

### 解释器的适用范围 ###

解释器模式适用于有一个语言需要解释执行，而且可以将该语言中的句子表示为一个抽象语法树。在下列情况下，效果最好：

1. 文法简单。

2. 效率不是一个关键问题。

### 示例 ###

加，减的文法解释示例：

import java.util.Map;
     
    interface Expression {
        public int interpret(Map<String,Expression> variables);
    }
     
    class Number implements Expression {
        private int number;
        public Number(int number)       { this.number = number; }
        public int interpret(Map<String,Expression> variables)  { return number; }
    }
     
    class Plus implements Expression {
        Expression leftOperand;
        Expression rightOperand;
        public Plus(Expression left, Expression right) { 
            leftOperand = left; 
            rightOperand = right;
        }
     
        public int interpret(Map<String,Expression> variables)  { 
            return leftOperand.interpret(variables) + rightOperand.interpret(variables);
        }
    }
     
    class Minus implements Expression {
        Expression leftOperand;
        Expression rightOperand;
        public Minus(Expression left, Expression right) { 
            leftOperand = left; 
            rightOperand = right;
        }
     
        public int interpret(Map<String,Expression> variables)  { 
            return leftOperand.interpret(variables) - rightOperand.interpret(variables);
        }
    }
     
    class Variable implements Expression {
        private String name;
        public Variable(String name)       { this.name = name; }
        public int interpret(Map<String,Expression> variables)  { 
            if(null==variables.get(name)) return 0; //Either return new Number(0).
            return variables.get(name).interpret(variables); 
        }
    }

解析用：

import java.util.Map;
    import java.util.Stack;
     
    class Evaluator implements Expression {
        private Expression syntaxTree;
     
        public Evaluator(String expression) {
            Stack<Expression> expressionStack = new Stack<Expression>();
            for (String token : expression.split(" ")) {
                if  (token.equals("+")) {
                    Expression subExpression = new Plus(expressionStack.pop(), expressionStack.pop());
                    expressionStack.push( subExpression );
                }
                else if (token.equals("-")) {
                    // it's necessary remove first the right operand from the stack
                    Expression right = expressionStack.pop();
                    // ..and after the left one
                    Expression left = expressionStack.pop();
                    Expression subExpression = new Minus(left, right);
                    expressionStack.push( subExpression );
                }
                else                        
                    expressionStack.push( new Variable(token) );
            }
            syntaxTree = expressionStack.pop();
        }
     
        public int interpret(Map<String,Expression> context) {
            return syntaxTree.interpret(context);
        }
    }

测试：

import java.util.Map;
    import java.util.HashMap;
     
    public class InterpreterExample {
        public static void main(String[] args) {
            String expression = "w x z - +";
            Evaluator sentence = new Evaluator(expression);
            Map<String,Expression> variables = new HashMap<String,Expression>();
            variables.put("w", new Number(5));
            variables.put("x", new Number(10));
            variables.put("z", new Number(42));
            int result = sentence.interpret(variables);
            System.out.println(result);
        }
    }

[Image 1]: