设计模式(16)之解释器模式

一、什么是解释器模式

Interpreter模式也叫解释器模式，是行为模式之一，它是一种特殊的设计模式，它建立一个解释器，对于特定的计算机程序设计语言，用来解释预先定义的文法。简单地说，Interpreter模式是一种简单的语法解释器构架。

二、解释器模式应用场景

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

     该文法简单对于复杂的文法, 文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。它们无需构建抽象语法树即可解释表达式, 这样可以节省空间而且还可能节省时间。 

    效率不是一个关键问题，最高效的解释器通常不是通过直接解释语法分析树实现的, 而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下, 转换器仍可用解释器模式实现, 该模式仍是有用的。

三、解释器模式的角色和职责

Context 解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等。
AbstractExpression 解释器抽象类。
ConcreteExpression 解释器具体实现类。

其实很抽象，举一个栗子：写一个解释自增和自减功能的解释器。

首先，是定义解释器的上下文环境，因为自增、自减都有一个输入和输出，so：

//Context.java
public class Context {

    private String input;
    private int output;

    public Context(String input){
        this.input = input;
    }

    public String getInput() {
        return input;
    }

    public void setInput(String input) {
        this.input = input;
    }

    public int getOutput() {
        return output;
    }

    public void setOutput(int output) {
        this.output = output;
    }
}

然后，定义抽象解释器类:

//Expression.java
public abstract class Expression {

    public abstract void interpret(Context context);
}

再然后定义具体的解释器的实现，这里是实现了一个自增和自减的解释器，其中，最重要的是，每次操作完上下文之后，一定要重置上下文环境的状态，这样之前的操作才能对后续的操作产生连锁反应：

//PlusExpression.java
public class PlusExpression extends Expression{

    public void interpret(Context context) {
        System.out.println("自动递增");
        //1.获取上下文环境
        String input = context.getInput();
        //2.进行操作
        int intInput =  Integer.parseInt(input);
        ++intInput;
        //3.重新设置上下文环境
        context.setInput(String.valueOf(intInput));
        context.setOutput(intInput);

    }

}

//MinusExpression.java
public class MinusExpression extends Expression{

    @Override
    public void interpret(Context context) {
        System.out.println("自动递减");

        String input = context.getInput();
        int intInput = Integer.parseInt(input);

        --intInput;

        //重新设置Context的状态，切记~~~
        context.setInput(String.valueOf(intInput));
        context.setOutput(intInput);

    }


}

最后，是测试方法：

//MainClass.java
import java.util.ArrayList;
import java.util.List;


public class MainClass {
    public static void main(String[] args) {

        String number = "10";
        Context context = new Context(number);
//      
//      PlusExpression plusExpression = new PlusExpression();
//      plusExpression.interpret(context);
//      System.out.println(context.getOutput());
//      
//      MinusExpression minusExpression = new MinusExpression();
//      minusExpression.interpret(context);
//      System.out.println(context.getOutput());        

        List<Expression> list = new ArrayList<Expression>();
        list.add(new PlusExpression());
        list.add(new PlusExpression());
        list.add(new MinusExpression());
        list.add(new MinusExpression());
        list.add(new PlusExpression());


        for(Expression e: list){
            e.interpret(context);
            System.out.println(context.getOutput());
        }

    }
}