Behavioral Patterns Part 3/11: Interpreter Pattern

Behavioral Patterns Part 3/11: Interpreter Pattern

目录

---

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