解释器Interpreter

所谓解释器模式就是定义一个语言的文法，并建立一个解释器来解释该语言中的句子！

比如：taglib标签，正则表达式都是采用的解释器。

 

解释器不仅仅只定义一种语法语义，更可以使用一个抽象语法树定义一个语言实例。

解释器角色：

    AbstractExpression: 抽象表达式。声明一个抽象的解释操作，该接口为抽象语法树中所有的节点共享。

   TerminalExpression: 终结符表达式。实现与文法中的终结符相关的解释操作。实现抽象表达式中所要求的方法。文法中每一个终结符都有一个具体的终结表达式与之相对应。

   NonterminalExpression: 非终结符表达式。为文法中的非终结符相关的解释操作。

   Context: 环境类。包含解释器之外的一些全局信息。

   Client: 客户类。  抽象语法树描述了如何构成一个复杂的句子，通过对抽象语法树的分析，可以识别出语言中的终结符和非终结符类。 在解释器模式中由于每一种终结符表达式、非终结符表达式都会有一个具体的实例与之相对应，所以系统的扩展性比较好。

 

  下面用解释器处理上面的例子： 5*6/3%4

  

 

 

//抽象表达式
public interface Node{
    public int interpret();
}

//非终结表达式实现
public class ValueNode implements Node{
    private int value;
    
    public ValueNode(int value){
        this.value=value;
    }
        
    public int interpret(){
        return this.value;
    }
}

     

//抽象终结表达式
public abstract class SymbolNode implements Node{
    public Node left;
    public Node right;

    public  SymbolNode(Node left,Node right){
       this.left=left;
       this.right=right;
    }
}

 

//乘法
public class MulNode extends SymbolNode{
   public MulNode(Node left,Node right){
       super(left,right);
   }
  
   public int interpret(){
       return left*right;
   }
}

//除法
public class DevNode extends SymbolNode{
   public DevNode(Node left,Node right){
        super(left,right);
   }

   public int interpret(){
        return left/right;
   }
}

//取模
public class MolNode extends SymbolNode{
    public MolNode(Node left,Node right){
         super(left,right);
    }

    public int interpret(){
         return left%right;
    }
}

 

public class Calculator{
    public int result;
    public Calculator(String expStr) {  
        // 定义一个堆栈，安排运算的先后顺序  
        Stack<Node> stack = new Stack<Node>();  
        // 表达式拆分为字符数组  
        char[] charArray = expStr.toCharArray();  
        // 运算  
        Node left = null;  
        Node right = null;  
        for (int i = 0; i < charArray.length; i++) {  
            switch (charArray[i]) {  
            case '*': //  
                // 结果放到堆栈中  
                left = stack.pop();  
                right =new ValueNode( Integer.parseInt(String.valueOf(charArray[++i])));  
                stack.push(new MulNode(left, right));  
                break;  
            case '/':  
                left = stack.pop();  
                right = new ValueNode( Integer.parseInt(String.valueOf(charArray[++i])));  
                stack.push(new DevNode(left, right));  
                break;  
             case '%':  
                left = stack.pop();  
                right =  new ValueNode(Integer.parseInt(String.valueOf(charArray[++i])));   
                stack.push(new MolNode(left, right));  
                break;
            default: // 公式中的变量  
                        stack.push(new ValueNode(Integer.parseInt(String.valueOf(charArray[++i])))); 
            }  
      this.result=stack.pop();
  }

  public int getResult(){
      return this.result;
  }
}
  

 

//客户端
main(){
   String express="5*6/3%4";
   Calculator  c=new Calculator (express);
   System.out.print(c.getResult());
}

 

 

解释器模式扩展性强，能处理表达式中重复出现的问题，但是应用场景少。