解释器模式

想名真难

已于 2022-06-04 22:03:00 修改

阅读量748

点赞数

分类专栏：设计模式文章标签：解释器模式

于 2016-08-13 18:15:51 首次发布

原文链接：http://t.zoukankan.com/yysbolg-p-7469634.html

版权

设计模式专栏收录该内容

32 篇文章 0 订阅

订阅专栏

Interpreter模式也叫解释器模式，是由GoF提出的23种设计模式中的一种。Interpreter是行为模式之一，它是一种特殊的设计模式，它建立一个解释器，对于特定的计算机程序设计语言，用来解释预先定义的文法。

正则表达式和浏览器都可以看做解释器模式的具体应用.

尽量不要在重要的模块中使用解释器模式，否则维护会是一个很大的问题。在项目中可以使用shell、JRuby、Groovy等脚本语言来代替解释器模式，解释器模式在实际的系统开发中使用的非常少，因为它会引起效率、性能以及维护等问题，一般在大中型的框架型项目能够找到它的身影，比如一些数据分析工具、报表设计工具、科学计算工具等等，若你确实遇到“一种特定类型的问题发生的频率足够高”的情况，准备使用解释器模式时，可以考虑一下开源的解析工具包（这三个开源产品都可以百度、Google中搜索到，请读者自行查询），功能都异常强大，而且非常容易使用，效率也还不错，实现大多数的数学运算完全没有问题，自己没有必要从头开始编写解释器，有人已经建立了一条康庄大道，何必再走自己的泥泞小路呢。

结构图：

解释器模式的结构

抽象解释器：声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。具体解释任务由它的各个实现类来完成，具体的解释器分别由终结符解释器TerminalExpression和非终结符解释器NonterminalExpression完成。
终结符表达式：实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，但有多个实例，对应不同的终结符。终结符一半是文法中的运算单元，比如有一个简单的公式R=R1+R2，在里面R1和R2就是终结符，对应的解析R1和R2的解释器就是终结符表达式。
非终结符表达式：文法中的每条规则对应于一个非终结符表达式，非终结符表达式一般是文法中的运算符或者其他关键字，比如公式R=R1+R2中，+就是非终结符，解析+的解释器就是一个非终结符表达式。非终结符表达式根据逻辑的复杂程度而增加，原则上每个文法规则都对应一个非终结符表达式。
环境角色：这个角色的任务一般是用来存放文法中各个终结符所对应的具体值，比如R=R1+R2，我们给R1赋值100，给R2赋值200。这些信息需要存放到环境角色中，很多情况下我们使用Map来充当环境角色就足够了。

代码举例（我已经最简单化了，一看即懂）

/// <summary>
/// 解释器上下文环境类。用来存储解释器的上下文环境，比如需要解释的文法等。
/// </summary>
class Context
{
    private int sum;
    public int Sum
    {
        get { return sum; }
        set { sum=value;}
    }
 
}
/// <summary>
/// 解释器抽象类。
/// </summary>
abstract class AbstractExpreesion
{
    public abstract void Interpret(Context context);
}

/// <summary>
///   解释器具体实现类。自加
/// </summary>
class PlusExpression : AbstractExpreesion
{
    public override void Interpret(Context context)
    {
        int sum = context.Sum;
        sum++;
        context.Sum = sum;

    }
}
/// <summary>
///   解释器具体实现类。 自减
/// </summary>
class MinusExpression : AbstractExpreesion
{
    public override void Interpret(Context context)
    {
        int sum = context.Sum;
        sum--;
        context.Sum = sum;

    }
}

客户端调用

class Program
{
    static void Main(string[] args)
    {
        Context context = new Context();
        context.Sum = 10;
        List<AbstractExpreesion> list = new List<AbstractExpreesion>();
        //运行加法三次
        list.Add(new PlusExpression());
        list.Add(new PlusExpression());
        list.Add(new PlusExpression());
        //运行减法两次
        list.Add(new MinusExpression());
        list.Add(new MinusExpression());
        for (int i = 0; i < list.Count(); i++)
        {
            AbstractExpreesion expression = list[i];
            expression.Interpret(context);
        }
        Console.WriteLine(context.Sum);
        Console.ReadLine();
        //得出结果为11
    }
}

看完之后，是不是觉得很简单，无非是设定几个公式，然后统一进行执行。最终得到结果！设计模式代表的是一种思想，至于怎么千变万化就看大家的了.

解释器模式的优缺点

解释器是一个简单的语法分析工具，它最显著的优点就是扩展性，修改语法规则只需要修改相应的非终结符就可以了，若扩展语法，只需要增加非终结符类就可以了。

但是，解释器模式会引起类的膨胀，每个语法都需要产生一个非终结符表达式，语法规则比较复杂时，就可能产生大量的类文件，为维护带来非常多的麻烦。同时，由于采用递归调用方法，每个非终结符表达式只关心与自己相关的表达式，每个表达式需要知道最终的结果，必须通过递归方式，无论是面向对象的语言还是面向过程的语言，递归都是一个不推荐的方式。由于使用了大量的循环和递归，效率是一个不容忽视的问题。特别是用于解释一个解析复杂、冗长的语法时，效率是难以忍受的。

解释器模式的适用场景

在以下情况下可以使用解释器模式：

有一个简单的语法规则，比如一个sql语句，如果我们需要根据sql语句进行rm转换，就可以使用解释器模式来对语句进行解释。
一些重复发生的问题，比如加减乘除四则运算，但是公式每次都不同，有时是a+b-c*d，有时是a*b+c-d，等等等等个，公式千变万化，但是都是由加减乘除四个非终结符来连接的，这时我们就可以使用解释器模式。

注意事项

解释器模式真的是一个比较少用的模式，因为对它的维护实在是太麻烦了，想象一下，一坨一坨的非终结符解释器，假如不是事先对文法的规则了如指掌，或者是文法特别简单，则很难读懂它的逻辑。解释器模式在实际的系统开发中使用的很少，因为他会引起效率、性能以及维护等问题。

如果想看，有点卵用的例子，恩，在这

package com.xingoo.interpreter;

import java.util.HashMap;
/**
* 指定抽象表达式，具体表达式必须实现的方法
* @author xingoo
*
*/
abstract class Expression{
 /**
  * 以上下文环境为准，解释指定的表达式
  * @param ctx
  * @return
  */
 public abstract boolean interpret(Context ctx);
 /**
  * 检验两个表达式，是否相同
  */
 public abstract boolean equals(Object o);
 /**
  * 返回表达式代表的hashCode
  */
 public abstract int hashCode();
 /**
  * 转换成字符串
  */
 public abstract String toString();
}
/**
* 常量表达式
* @author xingoo
*
*/
class Constant extends Expression{
 private boolean value;
 public Constant(boolean value){
     this.value = value;
 }
 public boolean interpret(Context ctx){
     return value;
 }
 public boolean equals(Object o){
     if(o!=null && o instanceof Constant){
         return this.value == ((Constant)o).value;
     }
     return false;
 }
 public int hashCode() {
     return (this.toString()).hashCode();
 }
 public String toString() {
     return new Boolean(value).toString();
 }
}
/**
* 变量表达式
* @author xingoo
*
*/
class Variable extends Expression{
 private String name;
 
 public Variable(String name){
     this.name = name;
 }
 
 public boolean interpret(Context ctx) {
     return ctx.lookup(this);
 }
 
 public boolean equals(Object o) {
     if(o!=null && o instanceof Variable){
         return this.name.equals(((Variable)o).name);
     }
     return false;
 }

 public int hashCode() {
     return (this.toString()).hashCode();
 }
 public String toString() {
     return name;
 }
 
}
/**
* 与 表达式
* @author xingoo
*
*/
class And extends Expression{
 private Expression left,right;
 
 public And(Expression left,Expression right){
     this.left = left;
     this.right = right;
 }
 
 public boolean interpret(Context ctx) {
     return left.interpret(ctx) && right.interpret(ctx);
 }

 @Override
 public boolean equals(Object o) {
     if(o!=null && o instanceof And){
         return this.left.equals(((And)o).left) && this.right.equals(((And)o).right);
     }
     return false;
 }

 public int hashCode() {
     return (this.toString()).hashCode();
 }

 public String toString() {
     return "("+left.toString()+" AND "+right.toString()+")";
 }
}
/**
* 或 表达式
* @author xingoo
*
*/
class Or extends Expression{
 private Expression left,right;
 
 public Or(Expression left,Expression right){
     this.left = left;
     this.right = right;
 }
 
 public boolean interpret(Context ctx) {
     return left.interpret(ctx) || right.interpret(ctx);
 }

 public boolean equals(Object o) {
     if(o!=null && o instanceof Or){
         return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right);
     }
     return false;
 }

 public int hashCode() {
     return (this.toString()).hashCode();
 }

 public String toString() {
     return "("+left.toString()+" Or "+right.toString()+")";
 }
}
/**
* 非 表达式
* @author xingoo
*
*/
class Not extends Expression{
 private Expression exp;
 
 public Not(Expression exp){
     this.exp = exp;
 }
 
 public boolean interpret(Context ctx) {
     return !exp.interpret(ctx);
 }

 public boolean equals(Object o) {
     if(o!=null && o instanceof Not){
         return this.exp.equals(((Not)o).exp);
     }
     return false;
 }

 public int hashCode() {
     return (this.toString()).hashCode();
 }

 public String toString() {
     return "(Not "+exp.toString()+")";
 }
 
}
/**
* 上下文环境
* @author xingoo
*
*/
class Context{
 
 private HashMap map = new HashMap();
 
 public void assign(Variable var,boolean value){
     map.put(var, new Boolean(value));
 }
 
 public boolean lookup(Variable var) throws IllegalArgumentException{
     Boolean value = (Boolean)map.get(var);
     if(value == null){
         throw new IllegalArgumentException();
     }
     return value.booleanValue();
 }
}
public class Client {
 private static Context ctx;
 private static Expression exp;
 public static void main(String[] args) {
     ctx = new Context();
     Variable x = new Variable("x");
     Variable y = new Variable("y");
     
     Constant c = new Constant(true);
     
     //放入上下文中
     ctx.assign(x, false);
     ctx.assign(y, true);
     
     exp = new Or(new And(c,x),new And(y,new Not(x)));
     System.out.println("x = "+x.interpret(ctx));
     System.out.println("y = "+y.interpret(ctx));
     System.out.println(exp.toString() +" = "+exp.interpret(ctx));
 }
}

运行结果

x = false
y = true
((true AND x) Or (y AND (Not x))) = true

想名真难

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
复制链接

分享到 QQ

分享到新浪微博

扫一扫

专栏目录