Java设计模式--解释器模式

解释器模式

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

Interpreter Pattern

Given a language, define a representation for its grammar along with an interpreter that uses the representation to interpret sentences in the language.

类图

模式的结构与使用

解释器模式的结构中包括四个角色。

• 抽象表达式（AbstractExpression）：该角色为一个接口，负责定义抽象的解释操作。
• 终结符表达式（TerminalExpression）：实现AbstractExpression接口的类。该类将接口中的解释器操作实现为与文法中的终结符相关联的操作，即文法中的每个终结符需要一个TerminalExpression类。
• 非终结符表达式（NonterminalExpression）：实现AbstractExpression接口的类。文法中的每一条规则R::=R1R2…Rn都需要一个NonterminalExpression类。NonterminalExpression类为文法中的非终结符号实现解释操作，该解释操作通常使用递归用表示Ri到Rn的那些对象的解释操作。
• 上下文（Context）：包含解释器之外的一些全局信息。

简单的例子

Node的接口类Dog.java

package Interpreter;

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

Context的类Context.java

package Interpreter;

import java.util.StringTokenizer;

public class Context {
	StringTokenizer tokenizer;
	String token;
	
	public Context(String text) {
		setContext(text);
	}
	
	public void setContext(String text) {
		tokenizer = new StringTokenizer(text);
	}

	String nextToken() {
		if (tokenizer.hasMoreTokens()) {
			token = tokenizer.nextToken();
		} else 
			token = "";
		return token;
	}
}

Node的实现类SubjectPronounOrNounNode.java

package Interpreter;

public class SubjectPronounOrNounNode implements Node {

	String[] word = {"You", "He", "Teacher", "Student"};
	String token;
	boolean boo;
	
	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0;
		for (; 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.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.println(token + "(不是该语言中的语句)");
		}
	}
}

Node的实现类ObjectPronounOrNounNode.java

package Interpreter;

public class ObjectPronounOrNounNode implements Node {

	String[] word = {"Me", "Him", "Tiger", "Apple"};
	String token;
	boolean boo;
	
	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0;
		for (; 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.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.println(token + "(不是该语言中的语句)");
		}
	}
}

Node的实现类VerbNode.java

package Interpreter;

public class VerbNode implements Node {

	String[] word = {"Drink", "Eat", "Look", "beat"};
	String token;
	boolean boo;
	
	@Override
	public void parse(Context context) {
		token = context.nextToken();
		int i = 0;
		for (; 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.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.println(token + "(不是该语言中的语句)");
		}
	}
}

Node的实现类SubjectNode.java

package Interpreter;

public class SubjectNode implements Node {

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

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

Node的实现类PredicateNode.java

papackage Interpreter;

public class PredicateNode implements Node {

	Node verbNode, objectNode;
	
	@Override
	public void parse(Context text) {
		verbNode = new VerbNode();
		objectNode = new ObjectPronounOrNounNode();
		verbNode.parse(text);
		objectNode.parse(text);
	}

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

Node的实现类SentenceNode.java

package Interpreter;

public class SentenceNode implements Node {

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

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

测试类Application.java

package Interpreter;

public class Application {

	public static void main(String[] args) {
		String text = "Teacher beat tiger";
		Context context = new Context(text);
		Node node = new SentenceNode();
		node.parse(context);
		node.execute();
		System.out.println();
		text = "You eat apple";
		context.setContext(text);
		node.parse(context);
		node.execute();
	}
}

运行结果

老师打老虎
你吃苹果

解释器模式的优点

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

适用解释器模式的情景

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

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

下载源码请到

MyGitHub