求索阁

1.概述

这个模式是在不能叫做模式，它的作用是实现一种语言规范的解释器，比如罗马数字解释器。

2.实例

我们在这创建一个决策器。通过构建有两种语言，OR和AND，可以想象为一个单位，领导给出一些决策意见，比如谁或者谁提拔，谁和谁提拔等（这里面有嵌套），然后存入这个决策器中。主程序通过输入几个人名的组合得出一个是不是可能这些人被提拔的决策。

首先，我们对决策器中的语言进行一个抽象：

  1: public abstract class Expression {

  2:     abstract public boolean interpret(String str); 

  3: }
里面提供了一个对决策器中语句进行解释的接口。
然后，我们对参与提拔的输入进行构建：
  1: public class TerminalExpression extends Expression {

  2: 

  3:     private String literal = null;

  4: 

  5:     public TerminalExpression(String str) { 

  6:         literal = str; 

  7:     }

  8:     

  9:     @Override

 10:     public boolean interpret(String str) { 

 11:         StringTokenizer st = new StringTokenizer(str);

 12:         while (st.hasMoreTokens()) { 

 13:             String test = st.nextToken();

 14:             if (test.equals(literal)) {

 15:                 return true;

 16:             }

 17:         }

 18:         return false;

 19:     }

 20: 

 21: }
随后对两个表达式进行解释
  1: public class OrExpression extends Expression {

  2: 

  3:     private Expression expression1 = null;

  4:     private Expression expression2 = null;

  5: 

  6:     public OrExpression(Expression expression1, Expression expression2) { 

  7:         this.expression1 = expression1;

  8:         this.expression2 = expression2; 

  9:     }

 10: 

 11:     public boolean interpret(String str) { 

 12:         return expression1.interpret(str) || expression2.interpret(str);

 13:     } 

 14: 

 15: }
  1: public class AndExpression extends Expression {

  2:     private Expression expression1 = null;

  3:     private Expression expression2 = null;

  4: 

  5:     public AndExpression(Expression expression1, Expression expression2) { 

  6:         this.expression1 = expression1;

  7:         this.expression2 = expression2;

  8:     }

  9: 

 10:     public boolean interpret(String str) { 

 11:         return expression1.interpret(str) && expression2.interpret(str);

 12:     } 

 13: }
现在我们就可以构建一个决策，然后试一试这个决策器的作用了：
  1: public class MainInterpreter {

  2: 

  3:     /**

  4:      * this method builds the interpreter tree

  5:      * It defines the rule "Owen and (John or (Henry or Mary))"

  6:      * @return

  7:      */

  8:     static Expression buildInterpreterTree() 

  9:     {

 10:         // Literal

 11:         Expression terminal1 = new TerminalExpression("John");

 12:         Expression terminal2 = new TerminalExpression("Henry");

 13:         Expression terminal3 = new TerminalExpression("Mary");

 14:         Expression terminal4 = new TerminalExpression("Owen");

 15: 

 16:         // Henry or Mary

 17:         Expression alternation1 = new OrExpression(terminal2, terminal3); 

 18: 

 19:         // John or (Henry or Mary)

 20:         Expression alternation2 = new OrExpression(terminal1, alternation1);

 21: 

 22:         // Owen and (John or (Henry or Mary))

 23:         return new AndExpression(terminal4, alternation2);

 24:     }

 25: 

 26:     

 27:     /**

 28:      * main method - build the interpreter

 29:      *  and then interpret a specific sequence 

 30:      * @param args

 31:      */

 32:     public static void main(String[] args) {

 33:         

 34:         String context = "John";

 35: 

 36:         Expression define = buildInterpreterTree();

 37: 

 38:         System.out.println(context + " is " + define.interpret(context));

 39:     }

 40: }