设计模式之解释器模式

   解释器模式（Interpreter Pattern）是一种按照规定语法进行解析的方案，在现在项目中使用较少（谁没事干会去写一个PHP或者Ruby的解析器），其定义如下：Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language。给定一个语言, 定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

      解释器模式的通用类图如图27-4所示。

• AbstractExpression 抽象解释器

      具体的解释任务由各个实现类完成，具体的解释器分别由TerminalExpression和NonterminalExpression完成。

• TerminalExpression终结符表达式

      实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。具体到我们例子就是VarExpression类，表达式中的每个终结符都在堆栈中产生了一个VarExpression对象。

• NonterminalExpression 非终结符表达式

      文法中的每条规则对应于一个非终结表达式，具体到我们的例子就是加减法规则分别对应到AddExpression和SubExpression两个类。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。

• Context 环境角色

如下面的表达式：

3 * 4 / 2 % 4

可以使用如下文法来定义：

expression::=value|symbol;

symbol::=expression'+"expression|expression'-'expression|expression'%'expresson;

value::=an integer;//一个整数值

上面包含3条语法规则，第一句表示表达式的组成方式，其中value和symbol是后面2个语法单位的定义，每一条语句所定义的字符串如symbol和value称为语法构造成分或语法单位，符合：：=表示“定义为”。

语法单位对应终结符表达式和非终结符表达式，如本例symbol是非终结符表达式，他的组成元素可以使表达式，可以进一步分解，而value是终结符表达式，他的组成元素是基本的语法单位，不能再分解。

每个文法规则都可以表示为一个由这些类的实例构成的抽象语法树。

在解释器模式中，每一种终结符和非终结符都有一个具体类与之对应，正因为使用类来表示每一个语法规则，使得系统有较好的扩展性和灵活性。

 

实现  3 * 4 / 2 % 4 运算：

1.抽象表达式类Node

 

public interface Node {
public int interpret();

}

2.终结符表达式类ValueNode（值节点类）

public class ValueNode  implements Node{
    private int value;
    public ValueNode(int value)
    {
        this.value=value;
        
    }
    public int interpret()
    {
        return this.value;
    }
}

 

3.抽象非终结符表达式类SymbolNode

public abstract class SymbolNode implements Node{
    protected Node left,right;
    public SymbolNode(Node left,Node right)
    {
        this.left=left;
        this.right=right;
    }

}

他包含了所有非终结符表达式的共有的数据和行为，在本例中，由于所有的非终结符都对应左右2个操作部分，因此在该类定义了left和right2个Node类型的对象，

4.非终结符表达式MulNode

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

}

5.非终结符表达式ModNode

public class ModNode extends SymbolNode{
    public ModNode(Node left,Node right)
    {
        super(left,right);
        
    }
    public int interpret()
    {
        return super.left.interpret()%super.right.interpret();
    }
}

6:DivNode

public class DivNode extends SymbolNode{
    public DivNode(Node left,Node right)
    {
        super(left,right);
        
    }
    public int interpret()
    {
        return super.left.interpret()/super.right.interpret();
    }

}

 

辅助代码：

1.解释器封装类Calculator（计算器类）

public class Calculator {
    private String statement;
    private Node node;
    public void bulid(String statement)
    {
        Node left=null,right=null;
        Stack stack=new Stack();
        
        String[] statementArr=statement.split(" ");
        for(int i=0;i<statementArr.length;i++)
        {
            if(statementArr[i].equalsIgnoreCase("*"))
            {
                left=(Node)stack.pop();
                int val=Integer.parseInt(statementArr[++i]);
                right=new ValueNode(val);
                stack.push(new MulNode(left,right));
            }
            else if(statementArr[i].equalsIgnoreCase("/"))
            {
                left=(Node)stack.pop();
                int val=Integer.parseInt(statementArr[++i]);
                right=new ValueNode(val);
                stack.push(new DivNode(left,right));
              
            }
            else if(statementArr[i].equalsIgnoreCase("%"))
            {
                left=(Node)stack.pop();
                int val=Integer.parseInt(statementArr[++i]);
                right=new ValueNode(val);
                stack.push(new ModNode(left,right));
              
            }
            else
            {
                stack.push(new ValueNode(Integer.parseInt(statementArr[i])));
            }
             
            
        }
        this.node=(Node)stack.pop();
}
        public int compute()
        {
            return node.interpret();
        }
    

}

Calculator是本例核心之一，他极大地简化了客户类代码。在Calculator类中定义了如何构造一颗抽象的语法树，在构造了使用了stack。通过一系列操作，放置在栈中的是一个完整的表达式，通过栈的pop方法将其取出，再在compute（）方法中调用该表达式的interpret方法，程序执行时将递归调用每一个子表达式的interpret方法，即执行每一个封装在终结符表达式类和非终结符表达式类中的interpret（）方法。

 

客户端测试类Client：

public class Client {
    public static void main(String[ ] args)
    {
        String statement="3 * 4 / 2 % 4";
        Calculator c=new Calculator();
        c.bulid(statement);
        int result=c.compute();
        System.out.println(statement+"="+result);
        
    }

}