行为模式：Interpreter（解释器）

The following Reverse Polish notation example illustrates the interpreter pattern. The grammar
expression ::= plus | minus | variable | number
plus ::= expression expression '+'
minus ::= expression expression '-'
variable  ::= 'a' | 'b' | 'c' | ... | 'z'
digit = '0' | '1' | ... '9'
number ::= digit | digit number

defines a language which contains reverse Polish expressions like:
a b +
a b c + -
a b + c a - -

Following the interpreter pattern there is a class for each grammar rule.

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);     }}

While the interpreter pattern does not address parsing^[2] a parser is provided for completeness.

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);    }}

Finally evaluating the expression "w x z - +" with w = 5, x = 10, and z = 42.

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);    }}