23个java设计模式(二十三)-- 解释器模式

2016年03月28日 原创
关键词: java 设计模式
摘要 解释器模式给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

一、概述。

解释器模式给定一个语言,定义它的文法的一种表示,并定义一个解释器,这个解释器使用该表示来解释语言中的句子。

对于某些问题,我们可能希望用简单的语言来描述,即希望用简单的语言来实现一些操作,比如用简单语言实现简单的翻译操作。这是就可以使用解释器模式。

解释器模式是关于怎样实现一个简单语言的成熟模式,其关键是将每一个语法规则表示成一个类。

二、解释器模式的结构。

解释器模式包括四种角色:

  • 抽象表达式(Abstract Expression):该角色为一个接口,负责定义抽象的解释操作。
  • 终结符表达式(Terminal Expression):实现抽象表达式接口的类。该类将接口中的解释操作实现为与文法中的终结符相关联的操作。
  • 非终结符表达式(Nonterminal Expression):实现抽象表达式接口的类。文法中的每一条规则都需要一个非终结符表达式类,为文法中的非终结符号实现解释操作,该解释操作通常使用递归。
  • 上下文(Context):包含解释器之外的一些全局信息。

三、示例程序。

抽象表达式(Abstract Expression)

Node.java

public interface Node {
	void parse(Context context);
	void execute();
}

终结符表达式(Terminal Expression)

SubjectPronounOrNounNode.java

public class SubjectPronounOrNounNode implements Node{
	private String word[] = {"You","He","Teacher","Student"};
	private String token;
	private boolean flag;
	
	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0;
		for(;i<word.length;i++) {
			if(token.equalsIgnoreCase(word[i])) {
				flag = true;
				break;
			}
		}
		if(i==word.length)flag = false;
	}

	@Override
	public void execute() {
		if(flag) {
			if(token.equalsIgnoreCase(word[0]))
				System.out.print("你");
			if(token.equalsIgnoreCase(word[1]))
				System.out.print("他");
			if(token.equalsIgnoreCase(word[2]))
				System.out.print("老师");
			if(token.equalsIgnoreCase(word[3]))
				System.out.print("学生");
		}else {
			System.out.print(token+"(不是该语言中的语句)");
		}
	}

}

ObjectPronounOrNounNode.java

public class ObjectPronounOrNounNode implements Node {
	private String[] word = { "Me", "Him", "Tiger", "Apple" };
	private String token;
	private boolean flag;

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

	@Override
	public void execute() {
		if(flag) {
			if(token.equalsIgnoreCase(word[0]))
				System.out.print("我");
			if(token.equalsIgnoreCase(word[1]))
				System.out.print("他");
			if(token.equalsIgnoreCase(word[2]))
				System.out.print("老虎");
			if(token.equalsIgnoreCase(word[3]))
				System.out.print("苹果");
		} else {
			System.out.print(token+"(不是该语言中的语句)");
		}
	}

}

VerbNode.java

public class VerbNode implements Node{
	private String[] word = {"Drink","Eat","Look","Beat"};
	private String token;
	private boolean flag;
	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0;
		for(;i<word.length;i++) {
			if(token.equalsIgnoreCase(word[i])) {
				flag = true;
				break;
			}
		}
		if(i==word.length)flag = false;
	}

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

}

非终结符表达式(Nonterminal Expression)

SentenceNode.java

public class SentenceNode implements Node {
	private Node subjectNode, predicateNode;

	@Override
	public void parse(Context context) {
		subjectNode = new SubjectNode();
		predicateNode = new PredicateNode();
		subjectNode.parse(context);
		predicateNode.parse(context);
	}

	@Override
	public void execute() {
		subjectNode.execute();
		predicateNode.execute();
	}

}

SubjectNode.java

public class SubjectNode implements Node{
	private Node node;
	@Override
	public void parse(Context context) {
		node = new SubjectPronounOrNounNode();
		node.parse(context);
	}

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

}

PredicateNode.java

public class PredicateNode implements Node{
	private Node verbNode,objectNode;
	@Override
	public void parse(Context context) {
		verbNode = new VerbNode();
		objectNode = new ObjectPronounOrNounNode();
		verbNode.parse(context);
		objectNode.parse(context);
	}

	@Override
	public void execute() {
		verbNode.execute();
		objectNode.execute();
	}

}

上下文(Context)

Context.java

public class Context {
	private StringTokenizer tokenizer;
	private String token;
	public Context(String text) {
		setContext(text);
	}
	public void setContext(String text) {
		tokenizer = new StringTokenizer(text);
	}
	public String nextToken() {
		if(tokenizer.hasMoreTokens())
			token = tokenizer.nextToken();
		else 
			token = "";
		return token;
	}
}

测试程序

Example1Test.java

public class Example1Test {
	@Test
	public void testMain() {
		String text = "Teacher beat tiger";
		Context context = new Context(text);
		Node node = new SentenceNode();
		node.parse(context);
		node.execute();
		text = "You eat apple";
		context.setContext(text);
		System.out.println();
		node.parse(context);
		node.execute();
		text = "you look him";
		context.setContext(text);
		System.out.println();
		node.parse(context);
		node.execute();
	}
}

四、解释器模式的优点。

  1. 将每一个语法规则表示为一个类,方便于实现简单的语言。
  2. 由于使用类表示语法规则,可以较容易改变或扩展语言的行为。
  3. 通过在类结构中加入新的方法,可以在解释的同时增加新的行为。

五、适合使用解释器模式的情景。

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

注:如果文法过于复杂,那么过多的文法规则使我们很难维护所给出的类。