目的

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

类图

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

解释器类图.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. }
  6. public class TerminalExpression extends Expression{
  8.     private String literal = null;
  10.     public TerminalExpression(String str){
  11.         literal = str;
  12.     }
  14.     public boolean interpret(String str){
  15.         StringTokenizer st = new StringTokenizer(str);
  16.         while(st.hasMoreTokens()){
  17.             String test = st.nextToken();
  18.             if(test.equals(literal)){
  19.                 return true;
  20.             }
  21.         }
  22.         return false;
  23.     }
  24. }
  27. public class AndExpression extends Expression {
  29.     private Expression expression1 = null;
  30.     private Expression expression2 = null;
  32.     public AndExpression(Expression expression1, Expression expression2) {
  33.         this.expression1 = expression1;
  34.         this.expression2 = expression2;
  35.     }
  37.     public boolean interpret(String str) {
  38.         return expression1.interpret(str) && expression2.interpret(str);
  39.     }
  40. }
  43. public class OrExpression extends Expression {
  44.     private Expression expression1 = null;
  45.     private Expression expression2 = null;
  47.     public OrExpression(Expression expression1, Expression expression2) {
  48.         this.expression1 = expression1;
  49.         this.expression2 = expression2;
  50.     }
  52.     public boolean interpret(String str) {
  53.         return expression1.interpret(str) || expression2.interpret(str);
  54.     }
  55. }
  58. public class Client {
  60.     /**
  61.      * 构建解析树
  62.      */
  63.     public static Expression buildInterpreterTree() {
  64.         // Literal
  65.         Expression terminal1 = new TerminalExpression("A");
  66.         Expression terminal2 = new TerminalExpression("B");
  67.         Expression terminal3 = new TerminalExpression("C");
  68.         Expression terminal4 = new TerminalExpression("D");
  69.         // B C
  70.         Expression alternation1 = new OrExpression(terminal2, terminal3);
  71.         // A Or (B C)
  72.         Expression alternation2 = new OrExpression(terminal1, alternation1);
  73.         // D And (A Or (B C))
  74.         return new AndExpression(terminal4, alternation2);
  75.     }
  77.     public static void main(String[] args) {
  78.         Expression define = buildInterpreterTree();
  79.         String context1 = "D A";
  80.         String context2 = "A B";
  81.         System.out.println(define.interpret(context1));
  82.         System.out.println(define.interpret(context2));
  83.     }
  84. }
  87. 运行结果
  88. true
  89. false

JDK中的体现