解析器模式

一、什么是解释器模式

Interpreter模式也叫解释器模式，是行为模式之一，它是一种特殊的设计模式，它建立一个解释器，对于特定的计算机程序设计语言，用来解释预先定义的文法。简单地说，Interpreter模式是一种简单的语法解释器构架。

二、解释器模式应用场景

当有一个语言需要解释执行 , 并且你可将该语言中的句子表示为一个抽象语法树时，可使用解释器模式。而当存在以下情况时该模式效果最好：

该文法简单对于复杂的文法 , 文法的类层次变得庞大而无法管理。此时语法分析程序生成器这样的工具是更好的选择。它们无需构建抽象语法树即可解释表达式 , 这样可以节省空间而且还可能节省时间。

效率不是一个关键问题，最高效的解释器通常不是通过直接解释语法分析树实现的 , 而是首先将它们转换成另一种形式。例如，正则表达式通常被转换成状态机。但即使在这种情况下 , 转换器仍可用解释器模式实现 , 该模式仍是有用的。

三、解释器模式的结构

三、解释器模式的角色和职责

Context
解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等。

AbstractExpression
解释器抽象类。

ConcreteExpression
解释器具体实现类。

package com.dw.test;
/**
 * 上下文环境,用来保存文法
 * @author Administrator
 *
 */
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;
	}

}

package com.dw.test;

/**
 * 抽象解析器
 */
public abstract class Expression {
	public abstract void interpret(Context context);
}

package com.dw.test;

//ConcreteExpression解释器具体实现类。 
public class PlusExpression extends Expression {

	public void interpret(Context context) {
	//提示信息
     System.out.println("自动递增");
     //获得上下文环境
     String input=context.getInput();
     //进行类型转换
     int intInput=Integer.parseInt(input);
     //进行递增
     ++intInput;
     //对上下文环境进行重新赋值
     context.setInput(String.valueOf(intInput));
     context.setOutput(intInput);
	}

}

package com.dw.test;
public class MinusExpression extends Expression {

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

}

package com.dw.test;

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

public class MainClass {

	public static void main(String[] args) {
		String number = "20";
		Context context = new Context(number);
		
/*	Expression expression1 = new MinusExpression();
		expression1.interpret(context);
		System.out.println(context.getOutput());*/
		
//		Expression expression2 = new PlusExpression();
//		expression2.interpret(context);
//		System.out.println(context.getOutput());
//		
//    	Expression expression3 = new PlusExpression();
//		expression3.interpret(context);
//		System.out.println(context.getOutput());
//		
//		Expression expression4 = new PlusExpression();
//		expression4.interpret(context);
//		System.out.println(context.getOutput());
		
	List<Expression> list = new ArrayList<Expression>();
		list.add(new PlusExpression());
		list.add(new PlusExpression());
		list.add(new MinusExpression());
		list.add(new MinusExpression());
		list.add(new MinusExpression());
		list.add(new MinusExpression());
		
		for(Expression ex : list) {
			ex.interpret(context);
			System.out.println(context.getOutput());
		}
	}

}