解释器Interpreter

标签: 解释器 interpreter | 发表时间:2014-01-27 15:57 | 作者:wdt1988520
出处:http://www.iteye.com

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

比如: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());
}

 

 

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



已有 0 人发表留言,猛击->> 这里<<-参与讨论


ITeye推荐



相关 [解释器 interpreter] 推荐:

解释器Interpreter

- - 企业架构 - ITeye博客
所谓解释器模式就是定义一个语言的文法,并建立一个解释器来解释该语言中的句子. 比如:taglib标签,正则表达式都是采用的解释器. 解释器不仅仅只定义一种语法语义,更可以使用一个抽象语法树定义一个语言实例.     AbstractExpression: 抽象表达式. 声明一个抽象的解释操作,该接口为抽象语法树中所有的节点共享.

[译文] 使用 PyPy 编写解释器:Part 2

- chuang - python.cn(jobs, news)
[译者前言]:本系列译文译自 PyPy Status Blog 刊登的 Writing an Interpreter with PyPy 系列文章,原文作者为 Andrew Brown,该系列文章的版权属于原文作者所有,在此向 Andrew Brown 以及 PyPy Status Blog 表示致谢.

Java8之使用新JS解释器Nashorn编译Lambda表达式

- - 并发编程网 - ifeve.com
原文链接  作者: Tal Weiss  CEO of  Takipi   译者:踏雁寻花,xbkaishui  校对:方腾飞. 在最近的一篇 文章中,我了解了一下Java8和Scala是如何实现 Lambda 表达式的. 正如我们所知道的,Java8不仅对javac编辑器做了很大改进,它还加入了一个全新的项目—Nashorn.