当前位置: 首页 > 编程笔记 >

Java基于解释器模式实现定义一种简单的语言功能示例

姬浩渺
2023-03-14
本文向大家介绍Java基于解释器模式实现定义一种简单的语言功能示例,包括了Java基于解释器模式实现定义一种简单的语言功能示例的使用技巧和注意事项,需要的朋友参考一下

本文实例讲述了Java基于解释器模式实现定义一种简单的语言功能。分享给大家供大家参考,具体如下:

一 模式定义

解释器模式:就是给定一个语言的文法表示,并且定义一个解释器,用来解释语言中的句子。解释器模式描述了怎样在有了一个简单的文法后,使用模式设计解释这些语句。

二 模式举例

1 模式分析

我们自己设计一种语言来说明这一模式

(1)该语言区分大小写
(2)该语言以PROGRAM开头,END结尾
(3)PRINTLN表示打印一行并换行
(4)使用FOR…FROM…TO…END表示循环

示例语言内容如下:

PROGRAM PRINTLN start... FOR i FROM 90 TO 100 PRINTLN i END PRINTLN end...END

该句表示的意思是:首先打印“start…”换行,然后循环打印“90”换行、“91”换行、……“100”换行,最后打印“end…”换行。

2 该语言解释树结构

3 该语言解释器活动图

4 代码示例

4.1 创建上下文环境——Context

package com.demo.interpreter.context;
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map;
import java.util.StringTokenizer;
/**
 * 上下文环境
 *
 * @author
 *
 */
public class Context {
  // 待解析的文本内容
  private final StringTokenizer stringTokenizer;
  // 当前命令
  private String currentToken;
  // 用来存储动态变化信息内容
  private final Map<String, Object> map = new HashMap<String, Object>();
  /**
   * 构造方法设置解析内容
   *
   * @param text
   */
  public Context(String text) {
    // 使用空格分隔待解析文本内容
    this.stringTokenizer = new StringTokenizer(text);
  }
  /**
   * 解析文本
   */
  public String next() {
    if (this.stringTokenizer.hasMoreTokens()) {
      currentToken = this.stringTokenizer.nextToken();
    } else {
      currentToken = null;
    }
    return currentToken;
  }
  /**
   * 判断命令是否正确
   *
   * @param command
   * @return
   */
  public boolean equalsWithCommand(String command) {
    if (command == null || !command.equals(this.currentToken)) {
      return false;
    }
    return true;
  }
  /**
   * 获得当前命令内容
   *
   * @return
   */
  public String getCurrentToken() {
    return this.currentToken;
  }
  /**
   * 获得节点的内容
   *
   * @return
   */
  public String getTokenContent(String text) {
    String str = text;
    if (str != null) { // 替换map中的动态变化内容后返回 Iterator<String>
      // 替换map中的动态变化内容后返回
      Iterator<String> iterator = this.map.keySet().iterator();
      while (iterator.hasNext()) {
        String key = iterator.next();
        Object obj = map.get(key);
        str = str.replaceAll(key, obj.toString());
      }
    }
    return str;
  }
  public void put(String key, Object value) {
    this.map.put(key, value);
  }
  public void clear(String key) {
    this.map.remove(key);
  }
}

4.2 表达式接口——IExpressions

package com.demo.interpreter.express;
import com.demo.interpreter.context.Context;
/**
 *
 * 表达式接口
 *
 * @author
 *
 */
public interface IExpressions {
  /**
   * 解析
   *
   * @param context
   */
  public void parse(Context context);
  /**
   * 执行方法
   *
   * @param context
   */
  public void interpret();
}

4.3 主表达式——ProgramExpression

package com.demo.interpreter.express;
import com.demo.interpreter.context.Context;
/**
 * program 表达式
 *
 * @author
 *
 */
public class ProgramExpression implements IExpressions {
  // 上下文环境
  private final Context context;
  // 当前命令
  private final static String COMMAND = "PROGRAM";
  // 存储下一个表达式引用
  private IExpressions expressions;
  /**
   * 构造方法将待解析的内容传入
   *
   * @param text
   */
  public ProgramExpression(String text) {
    this.context = new Context(text);
    this.parse(this.context);
  }
  @Override
  public void parse(Context context) {
    // 获取第一个命令节点
    this.context.next();
  }
  /**
   * 实现解释方法
   */
  @Override
  public void interpret() {
    // 判断是否是以PROGRAM 开始
    if (!this.context.equalsWithCommand(COMMAND)) {
      System.out.println("The '" + COMMAND + "' is Excepted For Start!");
    } else {
      // 是以PROGRAM 开始
      this.context.next();
      this.expressions = new ListExpression();
      this.expressions.parse(this.context);
      // ListExpression表达式开始解析
      this.expressions.interpret();
    }
  }
}

4.4 列表表达式——ListExpression

package com.demo.interpreter.express;
import java.util.ArrayList;
import java.util.Iterator;
import com.demo.interpreter.context.Context;
/**
 * 列表表达式
 *
 * @author
 *
 */
public class ListExpression implements IExpressions {
  private Context context;
  private final ArrayList<IExpressions> list = new ArrayList<IExpressions>();
  /**
   * 构造方法将待解析的context传入
   *
   * @param context
   */
  public void parse(Context context) {
    this.context = context;
    // 在ListExpression解析表达式中,循环解释语句中的每一个单词,直到终结符表达式或者异常情况退出
    while (true) {
      if (this.context.getCurrentToken() == null) {
        // 获取当前节点如果为 null 则表示缺少END表达式
        System.out.println("Error: The Experssion Missing 'END'! ");
        break;
      } else if (this.context.equalsWithCommand("END")) {
        this.context.next();
        // 解析正常结束
        break;
      } else {
        // 建立Command 表达式
        IExpressions expressions = new CommandExperssion(this.context);
        // 添加到列表中
        list.add(expressions);
      }
    }
  }
  /**
   * 实现解释方法
   */
  @Override
  public void interpret() {
    // 循环list列表中每一个表达式 解释执行
    Iterator<IExpressions> iterator = list.iterator();
    while (iterator.hasNext()) {
      (iterator.next()).interpret();
    }
  }
}

4.5 命令表达式——CommandExperssion

package com.demo.interpreter.express;
import com.demo.interpreter.context.Context;
/**
 * 命令表达式
 *
 * @author
 *
 */
public class CommandExperssion implements IExpressions {
  private final Context context;
  private IExpressions expressions;
  /**
   * 构造方法将待解析的context传入
   *
   * @param context
   */
  public CommandExperssion(Context context) {
    this.context = context;
    this.parse(this.context);
  }
  public void parse(Context context) {
    // 判断当前命令类别 在此只对For和最原始命令进行区分
    if (this.context.equalsWithCommand("FOR")) {
      // 创建For表达式进行解析
      expressions = new ForExpression(this.context);
    } else {
      // 创建原始命令表达式进行内容解析
      expressions = new PrimitiveExpression(this.context);
    }
  }
  /**
   * 解析内容
   */
  @Override
  public void interpret() {
    // 解析内容
    this.expressions.interpret();
  }
}

4.6 循环表达式——ForExpression

package com.demo.interpreter.express;
import com.demo.interpreter.context.Context;
/**
 * For表达式
 *
 * @author
 *
 */
public class ForExpression implements IExpressions {
  private final Context context;
  // 存储当前索引key值
  private String variable;
  // 存储循环起始位置
  private int start_index;
  // 存储循环结束位置
  private int end_index;
  private IExpressions expressions;
  /**
   * 构造方法将待解析的context传入
   *
   * @param context
   */
  public ForExpression(Context context) {
    this.context = context;
    this.parse(this.context);
  }
  /**
   * 解析表达式
   */
  @Override
  public void parse(Context context) {
    // 首先获取当前节点
    this.context.next();
    while (true) {
      // 判断节点
      if (this.context.equalsWithCommand("FROM")) {
        // 设置开始索引内容
        String nextStr = this.context.next();
        try {
          this.start_index = Integer.parseInt(nextStr);
        } catch (Exception e) {
          System.out
              .println("Error: After 'FROM' Expression Exist Error!Please Check the Format Of Expression is Correct!");
          break;
        }
        // 获取下一个节点
        this.context.next();
      } else if (this.context.equalsWithCommand("TO")) {
        // 设置结束索引内容
        String nextStr = this.context.next();
        try {
          this.end_index = Integer.parseInt(nextStr);
        } catch (Exception e) {
          System.out
              .println("Error: After 'TO' Expression Exist Error!Please Check the Format Of Expression is Correct!");
        }
        this.context.next();
        break;
      } else {
        // 设置当前索引变量内容
        if (this.variable == null) {
          this.variable = this.context.getCurrentToken();
        }
        // 获取下一个节点
        this.context.next();
      }
    }
    // 建立列表表达式
    this.expressions = new ListExpression();
    this.expressions.parse(this.context);
  }
  /**
   * 实现解释方法
   */
  @Override
  public void interpret() {
    // 建立命令表达式
    for (int x = this.start_index; x <= this.end_index; x++) {
      // 设置变量内容
      this.context.put("" + this.variable, x);
      // 执行解释方法
      this.expressions.interpret();
    }
    // 移除使用的临时变量内容
    this.context.clear("" + this.variable);
  }
}

4.7 基础表达式——PrimitiveExpression

package com.demo.interpreter.express;
import com.demo.interpreter.context.Context;
/**
 * 最基础的表达式
 *
 * @author
 *
 */
public class PrimitiveExpression implements IExpressions {
  private Context context;
  // 节点名称
  private String tokenName;
  // 文本内容
  private String text;
  /**
   * 构造方法将待解析的context传入
   *
   * @param context
   */
  public PrimitiveExpression(Context context) {
    this.parse(context);
  }
  @Override
  public void parse(Context context) {
    this.context = context;
    this.tokenName = this.context.getCurrentToken();
    this.context.next();
    if ("PRINTLN".equals(this.tokenName)) {
      this.text = this.context.getCurrentToken();
      this.context.next();
    }
  }
  /**
   * 实现解释方法
   */
  @Override
  public void interpret() {
    // 首先获取当前节点内容
    if ("PRINTLN".equals(tokenName)) {
      // 获得内容信息
      // 打印内容
      System.out.println(this.context.getTokenContent(this.text));
    }
  }
}

4.8 让语言解释器开始工作——Client

package com.demo.interpreter;
import com.demo.interpreter.express.IExpressions;
import com.demo.interpreter.express.ProgramExpression;
/**
 * 主应用程序
 *
 * @author
 *
 */
public class Client {
  /**
   * @param args
   */
  public static void main(String[] args) {
    // myida语言语句
    String str = "PROGRAM PRINTLN start... FOR i FROM 90 TO 100 PRINTLN i END PRINTLN end... END";
    System.out.println("str:" + str);
    // 创建PROGRAM表达式
    IExpressions expressions = new ProgramExpression(str);
    // 解释执行
    expressions.interpret();
  }
}

5 运行结果

str:PROGRAM PRINTLN start... FOR i FROM 90 TO 100 PRINTLN i END PRINTLN end... END
start...
90
91
92
93
94
95
96
97
98
99
100
end...

三 设计原则

1 “开-闭”原则

2 封闭变化原则

四 使用场合

(1)一种特定类型的问题发生的频率足够高,并且业务规则频繁变化,不断重复出现类似情况。

(2)业务规则不是过于复杂烦琐,比较容易抽象出语法规则。

(3)效率不是软件系统中主要考虑的因素。

五 解释器模式静态类图

更多java相关内容感兴趣的读者可查看本站专题:《Java面向对象程序设计入门与进阶教程》、《Java数据结构与算法教程》、《Java操作DOM节点技巧总结》、《Java文件与目录操作技巧汇总》和《Java缓存操作技巧汇总》

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

 类似资料:
  • 有朋友一直在等待我的解释器模式文稿,,现把某个版本发在博客上,欢迎大家讨论!        虽然目前计算机编程语言有好几百种,但有时候我们还是希望能用一些简单的语言来实现一些特定的操作,我们只要向计算机输入一个句子或文件,它就能够按照预先定义的文法规则来对句子或文件进行解释,从而实现相应的功能。例如提供一个简单的加法/减法解释器,只要输入一个加法/减法表达式,它就能够计算出表达式结果,如图18-1

  • 18.6 解释器模式总结 解释器模式为自定义语言的设计和实现提供了一种解决方案,它用于定义一组文法规则并通过这组文法规则来解释语言中的句子。虽然解释器模式的使用频率不是特别高,但是它在正则表达式、XML文档解释等领域还是得到了广泛使用。与解释器模式类似,目前还诞生了很多基于抽象语法树的源代码处理工具,例如Eclipse中的Eclipse AST,它可以用于表示Java语言的语法结构,用户可以通过扩

  • 18.5 再谈Context的作用        在解释器模式中,环境类Context用于存储解释器之外的一些全局信息,它通常作为参数被传递到所有表达式的解释方法interpret()中,可以在Context对象中存储和访问表达式解释器的状态,向表达式解释器提供一些全局的、公共的数据,此外还可以在Context中增加一些所有表达式解释器都共有的功能,减轻解释器的职责。        在上面的机器人

  • 18.4 完整解决方案 为了能够解释机器人控制指令,Sunny软件公司开发人员使用解释器模式来设计和实现机器人控制程序。针对五条文法规则,分别提供五个类来实现,其中终结符表达式direction、action和distance对应DirectionNode类、ActionNode类和DistanceNode类,非终结符表达式expression和composite对应SentenceNode类和A

  • 18.3 解释器模式概述        解释器模式是一种使用频率相对较低但学习难度较大的设计模式,它用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下,为了更好地描述某一些特定类型的问题,我们可以创建一种新的语言,这种语言拥有自己的表达式和结构,即文法规则,这些问题的实例将对应为该语言中的句子。此时,可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想

  • 18.2 文法规则和抽象语法树        解释器模式描述了如何为简单的语言定义一个文法,如何在该语言中表示一个句子,以及如何解释这些句子。在正式分析解释器模式结构之前,我们先来学习如何表示一个语言的文法规则以及如何构造一棵抽象语法树。        在前面所提到的加法/减法解释器中,每一个输入表达式,例如“1 + 2 + 3 – 4 + 1”,都包含了三个语言单位,可以使用如下文法规则来定义: