设计模式 -- 解释器模式（Interpreter Pattern）

2015年12月15日00:19:02

今天只看了理论和demo,明天再写文章，跑步好累

2015年12月15日21:36:00

解释器模式用来解释预先定义的文法。

《大话设计模式》里面这么定义：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个势力表述为一个简单语言中的句子，这样就可以构建一个解释器，该解释器通过解释这些句子来解决问题。

解释器模式包含以下几个类：

1. AbstractExpression: 抽象表达式。声明一个抽象的解释操作，该接口为抽象语法树中所有的节点共享。
2. TerminalExpression: 终结符表达式。实现与文法中的终结符相关的解释操作。实现抽象表达式中所要求的方法。文法中每一个终结符都有一个具体的终结表达式与之相对应。
3. NonterminalExpression: 非终结符表达式。为文法中的非终结符相关的解释操作。
4. Context: 环境类。包含解释器之外的一些全局信息。
5. Client: 客户类。

优点：

容易改变和扩展文法，因为该模式使用类来标示文法规则，你可使用继承来改变和扩展该文法。也比较容易实现文法，因为定义抽象语法树种各个节点的类实现答题想死，这些类都抑郁编写。

缺点：解释器模式为文法中的每一条规则至少定义了一个类，因此包含许多规则的文法可能难以管理和维护，建议文法复杂的情况下使用其他技术如预防分析程序和编译器生成器来处理。

 下面是个demo:

首先创建环境类Context：

package InterpreterPattern;

/*
 * 上下文环境类，用来保存文法,包含解释器之外的一些全局信息
 */
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 类：

/**
 * 
 * @ClassName: Expression
 * @Description: TODO(解释器的抽象类，抽象解释器的解释操作) 
 */
public abstract class Expression {
    public abstract void interpret(Context context);
}

然后就是实现抽象类：

自减操作：

package InterpreterPattern;
/**
 * 
 * @ClassName: MinusExpression
 * @Description: TODO(自减操作) 
 */
public class MinusExpression extends Expression{
    
    @Override
    public void interpret(Context context) {
        System.out.println("自动递减");
        String input = context.getInput();
        int inInput = Integer.parseInt(input);
        --inInput;
        context.setInput(String.valueOf(inInput));
        context.setOutput(inInput);
    }
    
}

自加操作：

package InterpreterPattern;
/**
 * 
 * @ClassName: PlusExpression
 * @Description: TODO(自加操作) 
 */
public class PlusExpression extends Expression {

    @Override
    public void interpret(Context context) {
        System.out.println("自动递增");
        String input = context.getInput();
        int inInput = Integer.parseInt(input);
        ++inInput;
        context.setInput(String.valueOf(inInput));
        context.setOutput(inInput);
        
    }
    
}

测试类：

package InterpreterPattern;

import java.util.ArrayList;
import java.util.List;

/**
 * @ClassName: Test
 * @Description: TODO(测试类) 
 */
public class Test {
    
    public static void main(String[] args) {
        String number = "99";
        Context context = new Context(number);   
        List<Expression> list = new ArrayList<Expression>();
        list.add(new PlusExpression());
        list.add(new MinusExpression());
        for(Expression ex : list) {
            ex.interpret(context);
            System.out.println(context.getOutput());
        }
    }
    
}

运算结果为：

自动递增
100
自动递减
99