Interpreter(解释器)模式

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

二、解释器模式应用场景
    当有一个语言需要解释执行,并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。
    而当存在以下情况时该模式效果最好：
    该文法简单对于复杂的文法,文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。它们无需构建抽象语法树即可解释表达式,这样可以节省空间而且还可能节省时间。
    效率不是一个关键问题，最高效的解释器通常不是通过直接解释语法分析树实现的,而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下,转换器仍可用解释器模式实现,该模式仍是有用的。

三、解释器模式的结构



四、解释器模式的角色和职责
Context
    解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等。
AbstractExpression
    解释器抽象类。  抽象表达式，声明一个抽象的解释操作，这个接口为抽象语法树中所有的节点所共享。
ConcreteExpression
    解释器具体实现类。

 TerminalExpression:终结符表达式。实现与文法中的终结符相关联的解释操作，一个句子中的每个终结符需要该类的一个实例。

 NonterminalExpression:非终结符表达式，对于文法中的每一条规则R：：=R1R2..都需要一个NonterminalExpression类。为从R1到Rn的每个符号都维护一个AbstractExpression类型的实例变量。为文法中的非终结符实现解释操作，解释操作一般要递归地调用表示R1到Rn的那些对象的解释操作。

Context：上下文，包含解释器需要解释的全局信息。

Client:构建表示该文法定义的语言中一个特定的句子的抽象语法树。该抽象语法树由NonterminalExpression和TerminalExpression的实例装配而成。调用解释操作等。

协作:

Client构建一个句子，它是NonterminalExpression和TerminalExpress的实例的一个抽象语法树，然后初始化上下文并调用解释操作。

每一个非终结符表达式节点定义相应子表达式的解释操作。而各终结符表达式的解释操作构成了递归的基础。

每一节点的解释操作用上下文来存储和访问解释器的状态。

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

MinusExpression.java

public class MinusExpression extends Expression { 
 
    public void interpret(Context context) { 
        System.out.println("自动递减"); 
        String input = context.getInput(); 
        int inInput = Integer.parseInt(input); 
//      inInput--; 
        --inInput; 
        context.setInput(String.valueOf(inInput)); 
        context.setOutput(inInput); 
    } 
 
}

PlusExpression.java

public class PlusExpression extends Expression { 
 
    public void interpret(Context context) { 
        //提示信息 
        System.out.println("自动递增"); 
        //获得上下文环境 
        String input = context.getInput(); 
        //进行类型转换 
        int intInput = Integer.parseInt(input); 
        //进行递增 
//      intInput++; 
        ++intInput; 
        //对上下文环境重新进行赋值 
        context.setInput(String.valueOf(intInput)); 
        context.setOutput(intInput); 
    } 
 
}

MainClass.java

import java.util.ArrayList; 
import java.util.List; 
 
/* 
 * client 
 */ 
public class MainClass { 
    public static void main(String[] args) { 
        String number = "20"; 
        Context context = new Context(number); 
         
//      Expression expression1 = new MinusExpression(); 
//      expression1.interpret(context); 
//      System.out.println(context.getOutput()); 
//       
//      Expression expression2 = new PlusExpression(); 
//      expression2.interpret(context); 
//      System.out.println(context.getOutput()); 
//       
//      Expression expression3 = new PlusExpression(); 
//      expression3.interpret(context); 
//      System.out.println(context.getOutput()); 
//       
//      Expression expression4 = new PlusExpression(); 
//      expression4.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 MinusExpression()); 
        list.add(new MinusExpression()); 
         
        for(Expression ex : list) { 
            ex.interpret(context); 
            System.out.println(context.getOutput()); 
        } 
    } 
}