【设计模式】解释器模式

不念不忘少年蓝@ 2022-07-16 01:28 241阅读 0赞

# 前言 #

Github：[https://github.com/yihonglei/java-design-patterns][https_github.com_yihonglei_java-design-patterns]

# 一 解释器模式作用 #

给定一种语言，定义他的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中句子。

# 二 应用场景 #

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

# 三 参与对象 #

#  #

(1)AbstractExpression(抽象表达式)

声明一个所有具体表达式都要实现的抽象接口（或者抽象类），接口中主要是一个interpret()方法，称为解释操作。

(2)TerminalExpression(终结符表达式)

实现与文法中的元素相关联的解释操作，通常一个解释器模式中只有一个终结符表达式，对应一个实例。

(3)NonterminalExpression(非终结符表达式)

为文法中的非终结符实现解释(interpret)操作。

(4)Context(上下文)

包含解释器之外的一些全局信息。

(5)Client(客户端)

调用解释器。

# 四 实例分析 #

AbstractExpression

package com.jpeony.design.patterns.interpreter;
    
    /**
     * AbstractExpression: 声明一个所有具体表达式都要实现的抽象接口（或者抽象类），
     * 接口中主要是一个interpret()方法，称为解释操作
     *
     * @author yihonglei
     */
    public abstract class Expression {
        abstract void interpret(Context ctx);
    }

Expression

高级解释器

package com.jpeony.design.patterns.interpreter;
    
    /**
     * Expression:实现与文法中的元素相关联的解释操作
     *
     * @author yihonglei
     */
    public class AdvanceExpression extends Expression {
    
        @Override
        void interpret(Context ctx) {
            System.out.println("高级解析器");
        }
    
    }

普通解释器

package com.jpeony.design.patterns.interpreter;
    
    /**
     * Expression:实现与文法中的元素相关联的解释操作
     *
     * @author yihonglei
     */
    public class SimpleExpression extends Expression {
    
        @Override
        void interpret(Context ctx) {
            System.out.println("普通解释器");
        }
    
    }

Context

package com.jpeony.design.patterns.interpreter;
    
    import java.util.ArrayList;
    import java.util.List;
    
    /**
     * Context: 包含解释器之外的一些全局信息
     *
     * @author yihonglei
     */
    public class Context {
        private String context;
    
        private List list = new ArrayList();
    
        public String getContext() {
            return context;
        }
    
        public void setContext(String context) {
            this.context = context;
        }
    
        public List getList() {
            return list;
        }
    
        public void setList(List list) {
            this.list = list;
        }
    
        public void add(Expression eps) {
            list.add(eps);
        }
    
    
    }

Client

package com.jpeony.design.patterns.interpreter;
    
    /**
     * Client: 调用解释器
     *
     * @author yihonglei
     */
    public class Test {
        public static void main(String[] args) {
            Context ctx = new Context();
            ctx.add(new SimpleExpression());
            ctx.add(new AdvanceExpression());
            ctx.add(new SimpleExpression());
    
            for (int i = 0; i < ctx.getList().size(); i++) {
                Expression eps = (Expression) ctx.getList().get(i);
                eps.interpret(ctx);
            }
        }
    }

运行结果：

![Center][]

[https_github.com_yihonglei_java-design-patterns]: https://github.com/yihonglei/java-design-patterns
[Center]: /images/20220716/d3ee55b6e72f4b0e947a6f7a34f240a4.png