学习札记：设计模式之解释器模式

一.什么是解释器模式

给定一个语言，定义文法表示，并定义一个解释器去解释定义的句子。

二.解释器模式的写法

解释器模式，主要有抽象的解释器，终结表达式，非终结表达式和上下文。如果按输入字符串得到结果的计算器来理解，抽象的解释器定义任务也就是得到的结果，终结表达式表达的是字符对应的数字的解释操作，一般只有一个，而非终结的表达式有点像各种各样的符号计算顺便返回结果。上下文环境则是定义包含解释操作的其他环境。
这次我们看看代码，我们先定义一个抽象的解释器，持有上下文引用。

public abstract class AbstractExpression {
	protected abstract double interprete(Context context);
}

再来定义一组非终结表达式

/**
 * 非终结表达式
 * @author Seven
 *
 */
public abstract class NonTerminalExpression extends AbstractExpression{
	
	protected AbstractExpression expression1,expression2;

	public NonTerminalExpression(AbstractExpression expression1, AbstractExpression expression2) {
		super();
		this.expression1 = expression1;
		this.expression2 = expression2;
	}

}

/**
 * 加法表达式
 * @author Seven
 *
 */
public class PlusExpression extends NonTerminalExpression{

	public PlusExpression(AbstractExpression expression1, AbstractExpression expression2) {
		super(expression1, expression2);
	
	}

	@Override
	protected double interprete(Context context) {
		
		return expression1.interprete(context)+expression2.interprete(context);
	}

}

/**
 * 减法表达式
 * @author Seven
 *
 */
public class MinusExpression extends NonTerminalExpression{

	public MinusExpression(AbstractExpression expression1, AbstractExpression expression2) {
		super(expression1, expression2);
	
	}

	@Override
	protected double interprete(Context context) {
		
		
		return expression1.interprete(context)-expression2.interprete(context);

		
	}

}

我们再来定义一个终结表达式

/** 终结表达式
 * @author Seven
 *
 */
public class TerminalExpression extends AbstractExpression{

	String var;
	public TerminalExpression(String var) {
		super();
		this.var = var;
	}

	@Override
	protected double interprete(Context context) {
		return context.lookup(this);
		
		
	}

}

我们再来看看客户端测试

public class Client {

	public static void main(String[] args) {
		Context context = new Context();
		TerminalExpression a = new TerminalExpression("a");
		TerminalExpression b = new TerminalExpression("b");
		TerminalExpression c = new TerminalExpression("c");
		context.add(a, 4.0);
		context.add(b, 8.0);
		context.add(c, 2.0);
		// 以上定义将终结表达式所表示的内容一一对应起来，并放到上下文环境中。可以理解为也就是定义文法，解释器的规则。

		AbstractExpression abstractExpression = new MinusExpression(b, c); 
		System.out.println(abstractExpression.interprete(context));  //得到结果6

		AbstractExpression abstractExpression1 = new PlusExpression(b, c);
		System.out.println(abstractExpression1.interprete(context));//得到结果10

		AbstractExpression abstractExpression2 = new PlusExpression(abstractExpression, c); 
		System.out.println(abstractExpression2.interprete(context));//先执行abstractExpression的interprete得到结果6，在减去c的interpreter得到的值 然后得到结果8

//	        System.out.println(new MinusExpression(new PlusExpression(a,b), c).interprete(context));
	}

}

三.小结

以上就是一个解释器模式的代码写法，解释器模式是为了解决一些文法的表达和转换，采用的是一种递归调用，所以看上去不是很好理解，看下最后一个的测试代码。当我们有一些简单的文法表达式可使用解释器模式。