Android编程设计模式之解释器模式详解

本文实例讲述了Android编程设计模式之解释器模式。分享给大家供大家参考，具体如下：

一、介绍

解释器模式（Interpreter Pattern）是一种用的比较少的行为型模式，其提供了一种解释语言的语法或表达式的方式，该模式定义了一个表达式接口，通过该接口解释一个特定的上下文。在这么多的设计模式中，解释器模式在实际运用上相对来说要少很多，因为我们很少会自己去构造一个语言的文法。虽然如此，既然它能够在设计模式中有一席之位，那么必定有它的可用之处。

二、定义

给定一个语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。（其中语言就是我们需要解释的对象，文法就是这个语言的规律，解释器就是翻译机，通过文法来翻译语言。）

三、使用场景

如果某个简单的语言需要解释执行而且可以将该语言中的语句表示为一个抽象的语法树时可以考虑使用解释器模式。

在某些特定的领域出现不断重复的问题时，可以将该领域的问题转化为一种语法规则下的语句，然后构建解释器来解释该语句。

四、解释器模式的UML类图

UML类图：

Android编程设计模式之解释器模式详解

角色介绍：

AbstractExpression：抽象表达式，声明一个抽象的解释操作父类，并定义一个抽象的 interpret() 解释方法，其具体的实现在各个具体的子类解释器中完成。

TerminalExpression：终结符表达式，实现了抽象表达式角色所要求的接口，主要是一个interpret()方法；文法中的每一个终结符都有一个具体终结表达式与之相对应。比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。

NonterminalExpression：非终结符表达式，文法中的每一条规则都需要一个具体的非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，“+”就是非终结符，解析“+”的解释器就是一个非终结符表达式。

Context：上下文环境类，这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

Client：客户类，解析表达式，构建抽象语法树，执行具体的解释操作等。

通用代码如下：

/**
 * 抽象表达式
 */
public abstract class AbstractExpression {
  /**
   * 抽象的解析方法
   * @param context 上下文环境对象
   */
  public abstract void interpret(Context context);
}
/**
 * 终结符表达式
 */
public class TerminalExpression extends AbstractExpression{
  @Override
  public void interpret(Context context) {
    //实现文法中与终结符有关的解释操作
  }
}
/**
 * 非终结符表达式
 */
public class NonterminalExpression extends AbstractExpression{
  @Override
  public void interpret(Context context) {
    //实现文法中与非终结符有关的解释操作
  }
}
/**
 * 上下文环境类
 */
public class Context {
}
/**
 * 客户类
 */
public class Client {
  public static void main(String[] args) {
    //根据文法对特定句子构建抽象语法树后解释
  }
}

五、简单实现

我们使用解释器模式对“m+n+p”这个表达式进行解释，那么代表数字的m、n和p就可以看成终结符号，而“+”这个运算符号可以当做非终结符号。

抽象的算数运算解释器：

public abstract class ArithemticExpression {
  /**
   * 抽象的解析方法
   * 具体的解析逻辑由具体的子类实现
   *
   * @return 解析得到具体的值
   */
  public abstract int interpreter();
}

数字解释器：

public class NumExpression extends ArithemticExpression{
  private int num;
  public NumExpression(int num){
    this.num = num;
  }
  @Override
  public int interpreter() {
    return num;
  }
}

运算符号解释器：

public abstract class OperatorExpression extends ArithemticExpression{
  protected ArithemticExpression exp1, exp2;
  public OperatorExpression(ArithemticExpression exp1, ArithemticExpression exp2){
    this.exp1 = exp1;
    this.exp2 = exp2;
  }
}

具体的加法运算符解释器：

public class AdditionExpression extends OperatorExpression{
  public AdditionExpression(ArithemticExpression exp1,
      ArithemticExpression exp2) {
    super(exp1, exp2);
  }
  @Override
  public int interpreter() {
    return exp1.interpreter() + exp2.interpreter();
  }
}

处理解释器：

public class Calculator {
  //声明一个Stack栈储存并操作所有相关的解释器
  private Stack<ArithemticExpression> mExpStack = new Stack<ArithemticExpression>();
  public Calculator(String expression){
    //声明两个ArithemticExpression类型的临时变量，储存运算符左右两边的数字解释器
    ArithemticExpression exp1,exp2;
    //根据空格分割表达式字符串(比如1 + 2 + 3 + 4)
    String[] elements = expression.split(" ");
    /*
     * 遍历表达式元素数组
     */
    for(int i = 0; i < elements.length; i++){
      /*
       * 判断运算符号
       */
      switch (elements[i].charAt(0)) {
      case '+':
        //如果是加号，则将栈中的解释器弹出作为运算符号左边的解释器
        exp1 = mExpStack.pop();
        //同时将运算符号数组下标的下一个元素构造为一个数字解释器
        exp2 = new NumExpression(Integer.parseInt(elements[++i]));
        //通过上面的两个数字解释器构造加法运算解释器
        mExpStack.push(new AdditionExpression(exp1, exp2));
        break;
      default:
        /*
         * 如果为数字，直接构造数字解释器并压入栈
         */
        mExpStack.push(new NumExpression(Integer.valueOf(elements[i])));
        break;
      }
    }
  }
  /**
   * 计算结果
   *
   * @return 最终的计算结果
   */
  public int calculate(){
    return mExpStack.pop().interpreter();
  }
}

调用：

public class Client {
  public static void main(String[] args) {
    Calculator c = new Calculator("22 + 553 + 83 + 5");
    System.out.println("计算结果："+c.calculate());
  }
}

结果：

计算结果：663

如果相加如减法的操作，在Calculator中加入相应判断即可：

public class SubtractionExpression extends OperatorExpression{
  public SubtractionExpression(ArithemticExpression exp1,
      ArithemticExpression exp2) {
    super(exp1, exp2);
  }
  @Override
  public int interpreter() {
    return exp1.interpreter() - exp2.interpreter();
  }
}

Calculator中加入：

case '-':
  exp1 = mExpStack.pop();
  exp2 = new NumExpression(Integer.parseInt(elements[++i]));
  mExpStack.push(new SubtractionExpression(exp1, exp2));
  break;

从上面可以看出解释器模式很灵活，他将复杂问题可以简单化、模块化、分离实现、解释执行。

六、Android源码中解释器模式

1、PackageParser

PackageParser是对AndroidManifest.xml配置文件进行读取的，具体原理参考：解析AndroidManifest原理

七、总结

优点：

最大的优点使其灵活的扩展性，当我们想对文法规则进行扩展延伸时，只需要增加相应的非终结符解释器，并在构建抽象语法树时，使用到新增的解释器对象进行具体的解释即可，非常方便。

缺点：

每个语法都要产生一个非终结符表达式，语法规则比较复杂时，就可能产生大量的类文件，为维护带来了非常多的麻烦。

解释器模式由于使用了大量的循环和递归，效率是个问题，特别是用于解析复杂、冗长的语法时，效率是难以忍受的。

更多关于Android相关内容感兴趣的读者可查看本站专题：《Android开发入门与进阶教程》、《Android调试技巧与常见问题解决方法汇总》、《Android基本组件用法总结》、《Android视图View技巧总结》、《Android布局layout技巧总结》及《Android控件用法总结》

希望本文所述对大家Android程序设计有所帮助。

Android编程设计模式之解释器模式详解

相关推荐