解释器模式：给定一个语言。定义它的文法的一种表示，并定义一个解释器。这个解释器使用该表示解释语言中的句子。

首先定义一个抽象的解释接口AbstractExpression

public abstract class AbstractExpression {

    public abstract void interpret(Contexts context);
}

接着定义终结符表达式TerminalExpression

public class TerminalExpression extends AbstractExpression{

    @Override
    public void interpret(Contexts context) {

        System.out.println("终端解释器");    
    }

}

然后定义非终结符表达式

public class NonterminalExpression extends AbstractExpression{

    @Override
    public void interpret(Contexts context) {

        System.out.println("非终端解释器");   

    }

}

接着定义一个context 类

public class Contexts {

    private String input;
    private String output;

    public String getInput(){
        return input;
    }

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

    public String getOutput(){
        return output;
    }

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

}

client代码

public static void main(String[] args) {
      //解释器模式
       Contexts context=new Contexts();
       List<AbstractExpression> list=new ArrayList<AbstractExpression>();
       list.add(new TerminalExpression());
       list.add(new NonterminalExpression());
       list.add(new TerminalExpression());
       list.add(new TerminalExpression());

       Iterator<AbstractExpression> iterator=list.iterator();
       while(iterator.hasNext()){
           AbstractExpression expression=iterator.next();
           expression.interpret(context);
       }
    }