博客
关于我
简单的介绍一下Java设计模式:解释器模式
阅读量:431 次
发布时间:2019-03-06

本文共 5852 字,大约阅读时间需要 19 分钟。

目录

定义

解释器模式是类的行为型模式,给定一个语言之后,解释器模式可以定义出其文法的一种表示,并同时提供一个解释器,客户端可以使用这个解释器来解释这个语言中的句子

意图

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

主要解决问题

对于一些固定文法构建一个解释句子的解释器

优缺点

优点:

  • 扩展性好,灵活
  • 增加了新的解释表达式的方式
  • 易于实现简单的文法

缺点:

  • 使用场景较少
  • 对于复杂的文法比较难以维护
  • 会引起类膨胀
  • 采用递归调用方法,效率低

结构

涉及的角色:

  • 抽象表达式(Expression)角色:声明一个所有的具体表达式角色都需要实现的抽象接口,这个接口主要是一个interpret方法,称作解释操作
  • 终结符表达式(TerminalExpression)角色:这是一个具体角色
    • 实现了抽象表达式角色要求的接口,主要是一个interpret方法
    • 文法中的每一个终结符都有一个具体终结表达式与之相对应
  • 非终结符表达式(NonterminalExpression)角色:这是一个具体角色
    • 文法中的每一条规则R=R1R2...Rn都需要一个具体的非终结符表达式类
    • 对每一个R=R1R2...Rn中的符号都持有一个静态类型为Expression的实例变量
    • 实现解释操作interpret方法,解释操作以递归方式调用上面所提到的代表R1R2...Rn中的各个符号的实例变量
  • 客户端(Client)角色:建造一个抽象语法树,调用解释操作
  • 环境(Context)角色:提供解释器之外的一些全局信息,比如变量的真实量值等

示例

抽象表达式角色:

/** * 这个抽象类代表终结类和非终结类的抽象化 */public abstract class Expression {    /** 以环境类为准,本方法解释给定的任何一个表达式 */    public abstract boolean interpret(Context ctx);    /** 检验两个表达式在结构上是否相同 */    public abstract boolean equals(Object o);    /** 返回表达式的hashCode */    public abstract int hashCode();    /** 将表达式转换为字符串 */    public abstract String toString();}

终结表达式角色:

一个Constant对象代表一个布尔常量

public class Constant extends Expression {    private boolean value;    public Constant(boolean value) {        this.value = value;    }    /** 解释操作 */    @Override    public boolean interpret(Context ctx) {        return value;    }    /** 检验两个表达式在结构上是否相同 */    @Override    public boolean equals(Object o) {        if (o != null && o instanceof Constant) {            return this.value = ((Constant)o).value;        }        return false;    }    /** 返回表达式的hashCode */    @Override    public int hashCode() {        return (this.toString()).hashCode();    }    /** 将表达式转换为字符串 */    @Override    public String toString(){        return new Boolean(value).toString();    }}

一个Variable对象代表一个有名变量

public class Variable extends Expression {    private String name;    public Variable(String name) {        this.name = name;    }    /** 解释操作 */    @Override    public boolean interpret(Context ctx) {        return ctx.lookup(this);    }    /** 检验两个表达式在结构上是否相同 */    @Override    public boolean equals(Object o) {        if (o != null && o instanceof Variable) {            return this.name.equals(((Variable)o).name);        }        return false;    }    /** 返回表达式的hashCode */    @Override    public int hashCode() {        return (this.toString()).hashCode();    }    /** 将表达式转换为字符串 */    @Override    public String toString() {        return name;    }}

非终结表达式角色:

表示由两个布尔表达式通过逻辑与操作给出一个新的布尔表达式的操作:

public class And extends Expression {    private Expression left, right;    public And(Expression left, Expression right) {        this.left = left;        this.right = right;    }    /** 解释操作 */    @Override    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;    }    /** 返回表达式的hashCode */    @Override    public int hashCode() {        return (this.toString()).hashCode();    }    /** 将表达式转换为字符串 */    @Override    public String toString() {        return "(" + left.toString() + " AND " + right.toString() + ")";    }}

表示由两个布尔表达式通过逻辑或操作给出一个新的布尔表达式的操作:

public class Or extends Expression {    private Expression left, right;    public Or(Expression left, Expression right) {        this.left = left;        this.right = right;    }    /** 解释操作 */    @Override    public boolean interpret(Context ctx) {        return left.interpret(ctx) || right.interpret(ctx);    }    /** 检验两个表达式在结构上是否相同 */    @Override    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;    }    /** 返回表达式的hashCode */    @Override    public int hashCode() {        return (this.toString()).hashCode();    }    /** 将表达式转换为字符串 */    @Override    public String toString() {        return "(" + left.toString() + " OR " + right.toString() + ")";    }}

表示由一个布尔表达式通过逻辑非操作给出一个新的布尔表达式的操作:

public class Not extends Expression {    private Expression exp;    public Not(Expression exp) {        this.exp = exp;    }    /** 解释操作 */    @Override    public boolean interpret(Context ctx) {        return !exp.interpret(ctx);    }    /** 检验两个表达式在结构上是否相同 */    @Override    public boolean equals(Object o) {        if (o != null && o instanceof Not) {            return this.exp.equals(((Not)o).exp);        }        return false;    }    /** 返回表达式的hashCode */    @Override    public int hashCode() {        return (this.toString()).hashCode();    }    /** 将表达式转换为字符串 */    @Override    public String toString() {        return "(Not " + exp.toString() + ")";    }}

环境类定义出从变量到布尔值的一个映射:

public 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) {        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));    }}

适用情况

  • 系统有一个简单的语言可供解释
  • 一些重复发生的问题可以用这种简单的语言表达
  • 效率不是主要考虑的问题

转载地址:http://pliuz.baihongyu.com/

你可能感兴趣的文章
MySQL中的GROUP_CONCAT()函数详解与实战应用
查看>>
MySQL中的IO问题分析与优化
查看>>
MySQL中的ON DUPLICATE KEY UPDATE详解与应用
查看>>
mysql中的rbs,SharePoint RBS:即使启用了RBS,内容数据库也在不断增长
查看>>
mysql中的undo log、redo log 、binlog大致概要
查看>>
Mysql中的using
查看>>
MySQL中的关键字深入比较:UNION vs UNION ALL
查看>>
mysql中的四大运算符种类汇总20多项,用了三天三夜来整理的,还不赶快收藏
查看>>
mysql中的字段如何选择合适的数据类型呢?
查看>>
MySQL中的字符集陷阱:为何避免使用UTF-8
查看>>
mysql中的数据导入与导出
查看>>
MySQL中的时间函数
查看>>
mysql中的约束
查看>>
MySQL中的表是什么?
查看>>
mysql中穿件函数时候delimiter的用法
查看>>
Mysql中索引的分类、增删改查与存储引擎对应关系
查看>>
Mysql中索引的最左前缀原则图文剖析(全)
查看>>
MySql中给视图添加注释怎么添加_默认不支持_可以这样取巧---MySql工作笔记002
查看>>
Mysql中获取所有表名以及表名带时间字符串使用BetweenAnd筛选区间范围
查看>>
Mysql中视图的使用以及常见运算符的使用示例和优先级
查看>>