【设计模式】—— 解释器模式Interpret

最新推荐文章于 2024-11-23 20:58:36 发布

qq_489366879

最新推荐文章于 2024-11-23 20:58:36 发布

阅读量232

点赞数

CC 4.0 BY-SA版权

分类专栏： java 设计模式

本文链接：https://blog.youkuaiyun.com/qq_32352565/article/details/72667747

java 同时被 2 个专栏收录

129 篇文章

订阅专栏

设计模式

15 篇文章

订阅专栏

本文介绍了一种设计模式——语法解释器模式，通过自定义语言文法并定义解释器来进行解析。适用于复杂语法分析场景，强调解释结果而非效率。文章详细展示了Java实现的例子，包括抽象表达式、具体表达式及上下文环境。

摘要生成于 C知道，由 DeepSeek-R1 满血版支持，前往体验 >

模式意图

自定义某种语言后，给定一种文法标准，定义解释器，进行解析。

做过搜索的朋友们可能更了解一些，平时我们搜索所需要的词库，通常就需要用这种方式来实现。

应用场景

1 有复杂的语法分析场景

2 需要高效的解释，胜过快速的效率（即看中解释的结果，而放弃效率）

模式结构

Expression 语法解释器的抽线模型

/**
 * 指定抽象表达式，具体表达式必须实现的方法
 * @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();
}

以下是具体的解释器实现过程，这里主要模仿JAVA模式中的例子

/**
 * 常量表达式
 * @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()+")";
    }
    
}

Context 上下文环境，存储一些表达式的内容

/**
 * 上下文环境
 * @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();
    }
}

全部代码

  1 package com.xingoo.interpreter;
  2 
  3 import java.util.HashMap;
  4 /**
  5  * 指定抽象表达式，具体表达式必须实现的方法
  6  * @author xingoo
  7  *
  8  */
  9 abstract class Expression{
 10     /**
 11      * 以上下文环境为准，解释指定的表达式
 12      * @param ctx
 13      * @return
 14      */
 15     public abstract boolean interpret(Context ctx);
 16     /**
 17      * 检验两个表达式，是否相同
 18      */
 19     public abstract boolean equals(Object o);
 20     /**
 21      * 返回表达式代表的hashCode
 22      */
 23     public abstract int hashCode();
 24     /**
 25      * 转换成字符串
 26      */
 27     public abstract String toString();
 28 }
 29 /**
 30  * 常量表达式
 31  * @author xingoo
 32  *
 33  */
 34 class Constant extends Expression{
 35     private boolean value;
 36     public Constant(boolean value){
 37         this.value = value;
 38     }
 39     public boolean interpret(Context ctx){
 40         return value;
 41     }
 42     public boolean equals(Object o){
 43         if(o!=null && o instanceof Constant){
 44             return this.value == ((Constant)o).value;
 45         }
 46         return false;
 47     }
 48     public int hashCode() {
 49         return (this.toString()).hashCode();
 50     }
 51     public String toString() {
 52         return new Boolean(value).toString();
 53     }
 54 }
 55 /**
 56  * 变量表达式
 57  * @author xingoo
 58  *
 59  */
 60 class Variable extends Expression{
 61     private String name;
 62     
 63     public Variable(String name){
 64         this.name = name;
 65     }
 66     
 67     public boolean interpret(Context ctx) {
 68         return ctx.lookup(this);
 69     }
 70     
 71     public boolean equals(Object o) {
 72         if(o!=null && o instanceof Variable){
 73             return this.name.equals(((Variable)o).name);
 74         }
 75         return false;
 76     }
 77 
 78     public int hashCode() {
 79         return (this.toString()).hashCode();
 80     }
 81     public String toString() {
 82         return name;
 83     }
 84     
 85 }
 86 /**
 87  * 与 表达式
 88  * @author xingoo
 89  *
 90  */
 91 class And extends Expression{
 92     private Expression left,right;
 93     
 94     public And(Expression left,Expression right){
 95         this.left = left;
 96         this.right = right;
 97     }
 98     
 99     public boolean interpret(Context ctx) {
100         return left.interpret(ctx) && right.interpret(ctx);
101     }
102 
103     @Override
104     public boolean equals(Object o) {
105         if(o!=null && o instanceof And){
106             return this.left.equals(((And)o).left) && this.right.equals(((And)o).right);
107         }
108         return false;
109     }
110 
111     public int hashCode() {
112         return (this.toString()).hashCode();
113     }
114 
115     public String toString() {
116         return "("+left.toString()+" AND "+right.toString()+")";
117     }
118 }
119 /**
120  * 或 表达式
121  * @author xingoo
122  *
123  */
124 class Or extends Expression{
125     private Expression left,right;
126     
127     public Or(Expression left,Expression right){
128         this.left = left;
129         this.right = right;
130     }
131     
132     public boolean interpret(Context ctx) {
133         return left.interpret(ctx) || right.interpret(ctx);
134     }
135 
136     public boolean equals(Object o) {
137         if(o!=null && o instanceof Or){
138             return this.left.equals(((Or)o).left) && this.right.equals(((Or)o).right);
139         }
140         return false;
141     }
142 
143     public int hashCode() {
144         return (this.toString()).hashCode();
145     }
146 
147     public String toString() {
148         return "("+left.toString()+" Or "+right.toString()+")";
149     }
150 }
151 /**
152  * 非 表达式
153  * @author xingoo
154  *
155  */
156 class Not extends Expression{
157     private Expression exp;
158     
159     public Not(Expression exp){
160         this.exp = exp;
161     }
162     
163     public boolean interpret(Context ctx) {
164         return !exp.interpret(ctx);
165     }
166 
167     public boolean equals(Object o) {
168         if(o!=null && o instanceof Not){
169             return this.exp.equals(((Not)o).exp);
170         }
171         return false;
172     }
173 
174     public int hashCode() {
175         return (this.toString()).hashCode();
176     }
177 
178     public String toString() {
179         return "(Not "+exp.toString()+")";
180     }
181     
182 }
183 /**
184  * 上下文环境
185  * @author xingoo
186  *
187  */
188 class Context{
189     
190     private HashMap map = new HashMap();
191     
192     public void assign(Variable var,boolean value){
193         map.put(var, new Boolean(value));
194     }
195     
196     public boolean lookup(Variable var) throws IllegalArgumentException{
197         Boolean value = (Boolean)map.get(var);
198         if(value == null){
199             throw new IllegalArgumentException();
200         }
201         return value.booleanValue();
202     }
203 }
204 public class Client {
205     private static Context ctx;
206     private static Expression exp;
207     public static void main(String[] args) {
208         ctx = new Context();
209         Variable x = new Variable("x");
210         Variable y = new Variable("y");
211         
212         Constant c = new Constant(true);
213         
214         //放入上下文中
215         ctx.assign(x, false);
216         ctx.assign(y, true);
217         
218         exp = new Or(new And(c,x),new And(y,new Not(x)));
219         System.out.println("x = "+x.interpret(ctx));
220         System.out.println("y = "+y.interpret(ctx));
221         System.out.println(exp.toString() +" = "+exp.interpret(ctx));
222     }
223 }

运行结果

asd