设计模式：解释器模式

 

基本结构：

1、抽象表达式：接口，用于定义解释所需的方法。

2、终结符表达式：实现1接口，该类是以一一对应的关系，解释语句。每个表达式将由一个该类对其进行解释与存储。

3、非终结符表达式：实现1接口，该类负责解释语句，将语句委托给一个或多个2（终结符表达式）进行解释。

4、上下文：即被解释的语句。

 

 

对一个包含主谓宾的英文语句解释为汉语。

1、抽象表达式：

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午9:36:09 
* @version 1.0 
*/
public interface Node {
	public void parse(Context context);
	public void execute();
}

2、终结符表达式：

 

主语：

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午9:37:23 
* @version 1.0 
*/
public class Z implements Node {

	String [] word = {"you" , "He"};
	String token;
	boolean boo;
	
	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0;
		for(i=0;i<word.length;i++){
			if(token.equalsIgnoreCase(word[i])){
				boo = true;
				break;
			}
		}
		if(i == word.length){
			boo = false;
		}
	}

	@Override
	public void execute() {
		if(boo){
			if(token.equalsIgnoreCase(word[0]))
				System.out.println("你");
			if(token.equalsIgnoreCase(word[1]))
				System.out.println("他");
		}else{
			System.out.println(token + "(不是该语言中的语句)");
		}
	}

}

谓语：

 

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午9:47:40 
* @version 1.0 
*/
public class W implements Node {
	
	String [] word = {"Drink" , "Eat"};
	String token;
	boolean boo;

	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0;
		for(i = 0;i<word.length;i++){
			if(token.equalsIgnoreCase(word[i])){
				boo = true;
				break;
			}
		}
		if(i == word.length)
			boo = false;
	}

	@Override
	public void execute() {
		if(boo){
			if(token.equalsIgnoreCase(word[0]))
				System.out.println("喝");
			if(token.equalsIgnoreCase(word[1]))
				System.out.println("吃");
		}else{
			System.out.println(token + "(不是该语言中的语句)");
		}
	}

}

宾语：

 

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午9:54:32 
* @version 1.0 
*/
public class B implements Node {
	String [] word = {"water" ,"milk","bread"};
	String token;
	boolean boo;

	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0 ;
		for(i=0;i<word.length;i++){
			if(token.equalsIgnoreCase(word[i])){
				boo = true;
				break;
			}
		}
		if(i == word.length)
			boo = false;
	}

	@Override
	public void execute() {
		if(boo){
			if(token.equalsIgnoreCase(word[0]))
				System.out.println("水");
			if(token.equalsIgnoreCase(word[1]))
				System.out.println("牛奶");
			if(token.equalsIgnoreCase(word[2]))
				System.out.println("面包");
		}
		else{
			System.out.println(token + "不是该语言中的语句");
		}
	}
	
	
}

 

 

3、非终结表达式：

关注主语：

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午10:18:53 
* @version 1.0 
*/
public class ZNode implements Node {

	Node node;
	@Override
	public void parse(Context context) {
		node = new Z();
		node.parse(context);
	}

	@Override
	public void execute() {
		node.execute();
	}

}

关注谓语：

 

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午10:22:22 
* @version 1.0 
*/
public class WNode implements Node {
	Node node;

	@Override
	public void parse(Context context) {
		node = new W();
		node.parse(context);
	}

	@Override
	public void execute() {
		node.execute();
	}

}

关于宾语：

 

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午10:23:37 
* @version 1.0 
*/
public class BNode implements Node {
	Node node;

	@Override
	public void parse(Context context) {
		node = new B();
		node.parse(context);
	}

	@Override
	public void execute() {
		node.execute();
	}

}

关注整句的解析：

 

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午10:25:30 
* @version 1.0 
*/
public class SentenceNode implements Node {
	Node z,w,b;

	@Override
	public void parse(Context context) {
		z = new ZNode();
		w = new WNode();
		b = new BNode();
		z.parse(context);
		w.parse(context);
		b.parse(context);

	}

	@Override
	public void execute() {
		z.execute();
		w.execute();
		b.execute();
	}

}

4、上下文：

 

 

package interpreter;

import java.util.StringTokenizer;

/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午9:28:33 
* @version 1.0 
*/
public class Context {
	StringTokenizer tokenizer;
	String token;
	/**
	 * @param token
	 */
	public Context(String token) {
		super();
		setContext(token);
	}
	
	public void setContext(String token){
		tokenizer = new StringTokenizer(token);
	}
	
	String nextToken(){
		if(tokenizer.hasMoreTokens()){
			token = tokenizer.nextToken();
		}else{
			token = "";
		}
		return token;
	}
	
	

}

last、主函数：

 

 

package interpreter;
/** 
* @author  Jangle jangle@jangle.xyz: 
* @date 创建时间：2016年10月6日 上午10:28:54 
* @version 1.0 
*/
public class M {

	public static void main(String[] args) {
		
		String s = "he eat bread";
		Context context = new Context(s);
		Node node = new SentenceNode();
		node.parse(context);
		node.execute();

	}

}

结果输出：

 

 

他
吃
面包

 

 

 

优点：

1、将每个语法规则标识成一个类，方便于实现简单的语言。

2、由于使用类标识语法规则，可以较容易改变或拓展语言的行为。

3、通过在类结构中加入新的方法，可以这解释的同时增加新的行为。

 

 

 

 

 

 

使用情景：

 

当有一个简单的语言需要解释执行，并且可以将该语言的每一个规则表示为一个类时，可以使用解释器模式。