解释器模式(Interpreter pattern): 使用解释器模式为语言创建解释器，通常由语言的语法和语法分析来定义。

意图

为语言创建解释器，通常由语言的语法和语法分析来定义。

类图

  • TerminalExpression: 终结符表达式，每个终结符都需要一个 TerminalExpression
  • Context: 上下文，包含解释器之外的一些全局信息

image.png

实现

以下是一个规则检验器实现，具有 and 和 or 规则，通过规则可以构建一颗解析树，用来检验一个文本是否满足解析树定义的规则。
例如一颗解析树为 D And (A Or (B C))，文本 “D A” 满足该解析树定义的规则。
这里的 Context 指的是 String。

  1. public abstract class Expression {
  2.     public abstract boolean interpret(String str);
  3. }
  1. public class TerminalExpression extends Expression {
  3.     private String literal = null;
  5.     public TerminalExpression(String str) {
  6.         literal = str;
  7.     }
  9.     public boolean interpret(String str) {
  10.         StringTokenizer st = new StringTokenizer(str);
  11.         while (st.hasMoreTokens()) {
  12.             String test = st.nextToken();
  13.             if (test.equals(literal)) {
  14.                 return true;
  15.             }
  16.         }
  17.         return false;
  18.     }
  19. }
  1. public class AndExpression extends Expression {
  3.     private Expression expression1 = null;
  4.     private Expression expression2 = null;
  6.     public AndExpression(Expression expression1, Expression expression2) {
  7.         this.expression1 = expression1;
  8.         this.expression2 = expression2;
  9.     }
  11.     public boolean interpret(String str) {
  12.         return expression1.interpret(str) && expression2.interpret(str);
  13.     }
  14. }
  1. public class OrExpression extends Expression {
  2.     private Expression expression1 = null;
  3.     private Expression expression2 = null;
  5.     public OrExpression(Expression expression1, Expression expression2) {
  6.         this.expression1 = expression1;
  7.         this.expression2 = expression2;
  8.     }
  10.     public boolean interpret(String str) {
  11.         return expression1.interpret(str) || expression2.interpret(str);
  12.     }
  13. }
  1. public class Client {
  3.     /**
  4.      * 构建解析树
  5.      */
  6.     public static Expression buildInterpreterTree() {
  7.         // Literal
  8.         Expression terminal1 = new TerminalExpression("A");
  9.         Expression terminal2 = new TerminalExpression("B");
  10.         Expression terminal3 = new TerminalExpression("C");
  11.         Expression terminal4 = new TerminalExpression("D");
  12.         // B C
  13.         Expression alternation1 = new OrExpression(terminal2, terminal3);
  14.         // A Or (B C)
  15.         Expression alternation2 = new OrExpression(terminal1, alternation1);
  16.         // D And (A Or (B C))
  17.         return new AndExpression(terminal4, alternation2);
  18.     }
  20.     public static void main(String[] args) {
  21.         Expression define = buildInterpreterTree();
  22.         String context1 = "D A";
  23.         String context2 = "A B";
  24.         System.out.println(define.interpret(context1));
  25.         System.out.println(define.interpret(context2));
  26.     }
  27. }

JDK