设计模式之解释器模式

定义(From百度百科):
        Interpreter(解释器)模式是一种特殊的设计模式，它建立一个解释器（Interpreter）,
对于特定的计算机程序设计语言，用来解释预先定义的文法。
简单地说，Interpreter模式是一种简单的语法解释器构架。

UML类图:

抽象具体代码:

public class Client {
    public static void main(String[] args) {
        //
    }
}

public class Context {

}

public abstract class AbstractExpression {
    abstract void  interpret();
}

public class NonTerminal {

}

public class Terminal {

}

好吧这只是解释器模式的代码骨架
在此引用下wiki上的例子（不得不吐槽，就单独技术上，wiki比百度解释的不知道详细多少）

expression ::= plus | minus | variable | number
plus ::= expression expression '+'
minus ::= expression expression '-'
variable ::= 'a' | 'b' | 'c' | ... | 'z'
digit = '0' | '1' | ... | '9'
number ::= digit | digit number

interface Expression {
    public int interpret(final Map<String, Expression> variables);
}

class Number implements Expression {
    private int number;
    public Number(final int number)       { this.number = number; }
    public int interpret(final Map<String, Expression> variables)  { return number; }
}

class Plus implements Expression {
    Expression leftOperand;
    Expression rightOperand;
    public Plus(final Expression left, final Expression right) {
        leftOperand = left;
        rightOperand = right;
    }
        
    public int interpret(final Map<String, Expression> variables) {
        return leftOperand.interpret(variables) + rightOperand.interpret(variables);
    }
}

class Minus implements Expression {
    Expression leftOperand;
    Expression rightOperand;
    public Minus(final Expression left, final Expression right) {
        leftOperand = left;
        rightOperand = right;
    }
        
    public int interpret(final Map<String, Expression> variables) {
        return leftOperand.interpret(variables) - rightOperand.interpret(variables);
    }
}

class Variable implements Expression {
    private String name;
    public Variable(final String name)       { this.name = name; }
    public int interpret(final Map<String, Expression> variables) {
        if (null == variables.get(name)) return 0; // Either return new Number(0).
        return variables.get(name).interpret(variables);
    }
}

public class InterpreterExample {
    public static void main(final String[] args) {
        final String expression = "w x z - +";
        final Evaluator sentence = new Evaluator(expression);
        final 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));
        final int result = sentence.interpret(variables);
        System.out.println(result);
    }
}

模块说明:
AbstractExpression（抽象表达式）：在抽象表达式中声明了抽象的解释操作，它是所有终结符表达式和非终结符表达式的公共父类。
Terminal（终结符表达式）：终结符表达式是抽象表达式的子类，它实现了与文法中的终结符相关联的解释操作，在句子中的每一个终结符都是该类的一个实例。
通常在一个解释器模式中只有少数几个终结符表达式类，它们的实例可以通过非终结符表达式组成较为复杂的句子。
NonTerminal（非终结符表达式）：非终结符表达式也是抽象表达式的子类，它实现了文法中非终结符的解释操作，由于在非终结符表达式中可以包含终结符表达式，
也可以继续包含非终结符表达式，因此其解释操作一般通过递归的方式来完成。
Context（环境类）：环境类又称为上下文类，它用于存储解释器之外的一些全局信息，通常它临时存储了需要解释的语句。

应用场景:
正如百度所言，正则表达式

优缺点:
优点：
易于改变和扩展文法
每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言
实现文法较为容易
增加新的解释表达式较为方便

缺点：
对于复杂文法难以维护
执行效率较低

总结：
分离实现，解释执行

吐槽：大部分我也不大明白，乱...,先留下个坑吧，希望有天把这句话去掉