Behavioral Patterns Part 3/11: Interpreter Pattern

Behavioral Patterns Part 3/11: Interpreter Pattern

目录

Behavioral Patterns Part 311 Interpreter Pattern

目录

Definition

UML Class

Implementation

Definition

Interpreter Pattern 是这样一种模式(援引GoF的定义)：给定一种语言(language)，在定义这个语言的语法(grammar)的同时，定义一个解释器(interpreter)，这个解释器就用该语法来解析(parse)这个语言的句子。

它提供了一种检验 语言的语法或者表达式合法性 的方法。这个模式需要实现一个 表达式接口，这个接口的功能就是用来告知如何解释一个特定的上下文(context)。

Interpreter Pattern 经常用来做 SQL解析，符号处理引擎等。

何时使用？当希望按照特定的语法解析语句或者表达式时。

使用频率：

Low

UML Class

Implementation

创建一个 Expression 接口以及这个接口的具体实现类。 TerminalExpression 类作为 context 的主要解释器(interpreter)，OrExpression 和 AndExpression 类用来创建一个 组合表达式(combinational expressions)。

// Expression.java
package designpatterns.behavioralpatterns.interpreter;

public interface Expression {
public boolean interpret(String context);
}

// ExpressionImpl.java
package designpatterns.behavioralpatterns.interpreter;

class TerminalExpression implements Expression {

private String data;

public TerminalExpression(String data) {
this.data = data;
}

@Override
public boolean interpret(String context) {
if(context.contains(data)) {
return true;
}

return false;
}
}

class AndExpression implements Expression {

private Expression expr1 = null;
private Expression expr2 = null;

public AndExpression(Expression expr1, Expression expr2) {
this.expr1 = expr1;
this.expr2 = expr2;
}

@Override
public boolean interpret(String context) {
return expr1.interpret(context) && expr2.interpret(context);
}
}

class OrExpression implements Expression {

private Expression expr1 = null;
private Expression expr2 = null;

public OrExpression(Expression expr1, Expression expr2) {
this.expr1 = expr1;
this.expr2 = expr2;
}

@Override
public boolean interpret(String context) {
return expr1.interpret(context) || expr2.interpret(context);
}
}

// InterpreterDemo.java
package designpatterns.behavioralpatterns.interpreter;

public class InterpreterDemo {

/**
* Rule:
* Robert and John are male
*/
public static Expression getMaleExpression() {
Expression robert = new TerminalExpression("Robert");
Expression john = new TerminalExpression("John");

return new OrExpression(robert, john);
}

/**
* Rule:
* Julie is a married woman
*/
public static Expression getMarriedWomanExpression() {
Expression julie = new TerminalExpression("Julie");
Expression married = new TerminalExpression("Married");

return new AndExpression(julie, married);
}

public static void main(String[] args) {
Expression isMale = getMaleExpression();
Expression isMarriedWoman = getMarriedWomanExpression();

System.out.println("John is male ? " + isMale.interpret("John"));
System.out.println("Julie is a married woman ? " + isMarriedWoman.interpret("Married Julie"));
}
}

// output
John is male ? true
Julie is a married woman ? true