16、Android设计模式 - 解释器模式

解释器模式是一种行为模式,实际开发中用的很少,提供了一种解释语言的语法或表达式的方式。

定义了一个表达式接口,通过接口解释一个特定的上下文。类似于json解析器按一定的语法解析json的。

定义

给定一个语言,定义它的文法的一种表示,并定义一个解释器,该解释器使用该表示来解释语言中的句子。

什么是文法?文法就是语言的规则,语法。每一个语法都对应一个解释器对象,解释器根据语法来解释相应的句子。

举个例子,那汉语中的主谓宾结构来说,我们经常是自己是什么是这样说的,我是程序员`我是设计师…。那么,就可以把我是[职位]定义为一条文法。解释器一看见这样的文法,就能解析出来你的职业是[职业]

使用场景

  • 当一个语言需要解释执行,并且该语言中的句子可以表示为一个抽象的语法树时。
  • 某些重复出现的问题,可以用一种简单的语言来表示的时候,可以将这个问题转化为一种语法规则下的语句。

UML

 

  • AbstractExpression:抽象的解析方法。声明一个解析方法,具体实现在具体的子类中完成
  • TernimalExprission:实现对文法中与终结符有关的解释操作。
  • NonterminalExpression:实现对文法中的非终结符有关的解释操作。
  • Context:包含解释器之外的全部信息。
  • Client: 解析表达式,构建抽象语法书,执行具体的解释操作等。

简单实现

以数字计算为例,`a+b+c,如果使用解释器模式对表达式进行解释,那么a,b,c可以看做是终结负号,+看做是非终结负号。

抽象的解释器,定义每个解释器都有个方法提取结果值

public abstract class ArithmeticExpression {
    public abstract int interpret();
}

数字解释器,仅仅解释数字

public class NumExpression extends ArithmeticExpression {
   
     
    private int num;

    public NumExpression(int num) {
        this.num = num;
    }

    @Override
    public int interpret() {
        return num;
    }
}

抽象的运算符解释器,要求传入两个参数进行计算

public abstract class OperatorExpression extends ArithmeticExpression {
   
     
    protected ArithmeticExpression exp1,exp2;

    public OperatorExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        this.exp1 = exp1;
        this.exp2 = exp2;
    }
}

一个具体的加法运算符,解析出两个参数的和

public class AddExpression extends OperatorExpression {
   
     
    public AddExpression(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }

    @Override
    public int interpret() {
        return exp1.interpret()+exp2.interpret();
    }
}

一个计算类,处理与解析相关的业务

public class Calculator {
    private Stack<ArithmeticExpression> mExp = new Stack<>();
//使用的时候在构造方法里传入要计算的字符串。
    public Calculator(String expression) {
        //准备两个解释器
        ArithmeticExpression exp1, exp2; 
        //将字符串按空格分割
        String[] elements = expression.split(" ");
        for (int i = 0; i < elements.length; i++) {
            switch (elements[i].charAt(0)) {
                case '+':
                //如果是’+‘,说明是个运算符,将上一个数和下一个数相加,也就是当前下标i的i-1和i+1相加。
                //去除栈中前一次压如的数。也就是这个加号之前的计算结果。
                    exp1 = mExp.pop();
                    //取出这个加号后面的数,解析成数字,
                    exp2 = new NumExpression(Integer.valueOf(elements[++i]));
                    //将这两个数进行计算,并将结果压入栈中。
                    mExp.push(new AddExpression(exp1,exp2));
                    break;
                default:
                //如果是数字,就解析为数字,加入栈中。
                    mExp.push(new NumExpression(Integer.valueOf(elements[i])));
                    break;
            }
        }
    }
    public int calculate(){
        return mExp.pop().interpret();
    }

}

客户端调用

public class Client {
    public static void main(String[] args) {
        Calculator calculator = new Calculator("1 + 2 + 3");
        System.out.println(calculator.calculate());
    }
}

可以看到输出结果是

6

如果需要加上减号运算符呢?就子啊实现一个减号的解析器:

public class Subtraction extends OperatorExpression {
   
     
    public Subtraction(ArithmeticExpression exp1, ArithmeticExpression exp2) {
        super(exp1, exp2);
    }

    @Override
    public int interpret() {
        return exp1.interpret()-exp2.interpret();
    }
}

然后在计算的类里加一种判断:

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

客户端调用

public class Client {
    public static void main(String[] args) {
        Calculator calculator = new Calculator("1 + 2 + 3 - 1");
        System.out.println(calculator.calculate());
    }
}

可以看到输出结果变成了

5

上面只是一个简单的算术运算的解析。根据这个模式,可以增加很多运算法则,只要创建响应的解释器就可以。

由于解释器和文法是一一对应的,所以一个解释器只负责解析一种文法。我们可以为一种文法创建多个解释器,但不能用一个解释器解析多重文法。

解释器值负责解析单个的文法,所以解析树的建立就有距离的使用者去根据实际情况构建了。

总结

优点

  • 拓展性很灵活,需要增加新的解释器的时候,直接实现一个新的就行了,然后在实际运用中灵活构建语法树来运用。

缺点

  • 每一个文法都至少对应一个解释器,会产生大量的类,维护困难。
  • 对于复杂的文法,要构建语法书会非常繁琐,甚至需要构建多颗语法树。