JAVA设计模式之解释器模式

1. 什么是解释器模式？

    定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的“语言”是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。

注：此模式使用较少，本人也为使用过，想要掌握此模式需要一些形式语法的知识。

2. 角色

 

图片来源于网络

抽象解释器(Expression)：声明一个所有的具体表达式角色都需要实现的抽象接口。这个接口主要有一个称做解释操作的方法。

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

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

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

3. 优点

（1）易于改变和扩展文法。

（2）每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。

（3）实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。

（4）增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合“开闭原则”。

4. 缺点

（1）对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。

（1）执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

5. 使用场景

（1）有一个简单的语法规则，比如一个sql语句，如果我们需要根据sql语句进行rm转换，就可以使用解释器模式来对语句进行解释。

（2）一些重复发生的问题，比如加减乘除四则运算，但是公式每次都不同，有时是a+b-c*d，有时是a*b+c-d等，公式千变万化，但是都是由加减乘除四个非终结符来连接的，这时我们就可以使用解释器模式。

（3）解释器模式在实际的系统开发中使用的很少，因为他会引起效率、性能以及维护等问题。

6. 示例代码

import java.util.HashMap;
import java.util.Map;
 
//抽象表达式(Expression)
interface Expression {
    int interpret(Context context);
}
//终结符表达式(Terminal Expression)
class Constant implements Expression {
    private int i;
 
    public Constant(int i) {
        this.i = i;
    }
 
    @Override
    public int interpret(Context context) {
        return i;
    }
}
 
class Variable implements Expression {
    @Override
    public int interpret(Context context) {
        return context.LookupValue(this);
    }
}
//非终结符表达式(Nonterminal Expression)
class Add implements Expression {
    private Expression left, right;
 
    public Add(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
 
    @Override
    public int interpret(Context context) {
        return left.interpret(context) + right.interpret(context);
    }
}
 
class Sub implements Expression {
    private Expression left, right;
 
    public Sub(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
 
    @Override
    public int interpret(Context context) {
        return left.interpret(context) - right.interpret(context);
    }
}
 
class Mul implements Expression {
    private Expression left, right;
 
    public Mul(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
 
    @Override
    public int interpret(Context context) {
        return left.interpret(context) * right.interpret(context);
    }
}
 
class Div implements Expression {
    private Expression left, right;
 
    public Div(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
 
    @Override
    public int interpret(Context context) {
        return left.interpret(context) / right.interpret(context);
    }
}
//环境(Context)角色
class Context {
    private Map valueMap = new HashMap<>();
 
    public void addValue(Variable x, int y) {
        valueMap.put(x, y);
    }
 
    public int LookupValue(Variable x) {
        return (int) valueMap.get(x);
    }
}
 
//客户端
public class Main {
    public static void main(String[] args) {
        //(a*b)/(a-b+15000)
        Context context = new Context();
        Variable a = new Variable();
        Variable b = new Variable();
        Constant c = new Constant(15000);
 
        context.addValue(a, 14);
        context.addValue(b, 10000);
 
        Expression expression = new Div(new Mul(a, b), new Add(new Sub(a, b), c));
        System.out.println("Result = "+expression.interpret(context));
    }
}

转载地址http://blog.youkuaiyun.com/yanbober/article/details/45537601

【四川乐山程序员联盟，欢迎大家加群相互交流学习5 7 1 8 1 4 7 4 3】