java设计模式之解释器模式

刺骨的言语ヽ痛彻心扉 2022-12-22 11:21 139阅读 0赞

解释器模式(Interpreter Pattern)提供了评估语言的语法或表达的方式，它属于行为模式。这种模式实现了一个表达式接口，该接口解释一个特定的上下文。这种模式被用在SQL解析、符号处理引擎等。

**模式介绍：**

**意图：**给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。

**主要解决：**对于一些固定文法构建一个解释句子的解释器。

**何时使用：**如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决问题。

**如何解决：**构建语法树，定义终结符雨非终结符。

**关键代码：**构建环境类，包含解释器之外的一些全局信息，一般是HashMap。

**应用实例：**编译器、运算表达式计算。

**优点：**

*  可扩展性比较好，灵活。
 *  增加了新的解释表达式的方式。
 *  易于实现简单方法。

**缺点：**

*  可利用场景比较少。
 *  对于复杂的文法比较难维护。
 *  解释器模式会引起类膨胀。
 *  解释器模式采用递归调用方法。

**使用场景：**

*  可以将一个需要解释执行的语言中的句子标识为一个抽象语法树。
 *  一些重复出现的问题可以用一种简单的语言来进行表达。
 *  一个简单语法需要解释的场景。

**注意事项：**可利用场景比较少，java中如果遇到可以用expression4J代替。

**实现：**

创建一个接口Expression和实现了Expression接口的实体类。定义作为上下文中主要解释器的TerminalExpression类。其他的类OrExpression、AndExpression用于创建组合式表达式。

InterpreterPatternDemo使用Expression类创建规则和演示表达式的解析。

![watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70][]

**新建Expression.java接口：**

public interface Expression {
        public boolean interpret(String context);
    }

**创建实现接口的实体类：**

public class TerminalExpression implements Expression{
        private String data;
    
        public TerminalExpression(String data){
            this.data = data;
        }
    
        @Override
        public boolean interpret(String context) {
            if (context.contains(data)){
                return true;
            }
            return false;
        }
    }

public class OrExpression implements Expression{
        private Expression expr1 =  null;
        private Expression expr2 = null;
    
        public OrExpression(Expression expr1,Expression expr2){
            this.expr1 = expr1;
            this.expr2 = expr2;
        }
    
        @Override
        public boolean interpret(String context) {
            return expr1.interpret(context)||expr2.interpret(context);
        }
    }

public class AndExpression implements Expression{
        private Expression expr1 = null;
        private Expression expr2 = null;
    
        public AndExpression(Expression expr1,Expression expr2){
            this.expr1 = expr1;
            this.expr2 = expr2;
        }
        @Override
        public boolean interpret(String context) {
            return expr1.interpret(context)&&expr2.interpret(context);
        }
    }

**InterprePatternDemo使用Expression来创建规则，并解析它们：**

/**
     * InterpreterPatternDemo使用expression类来创建规则，并解析它们
     */
    public class InterpreterPatternDemo {
    
        //规则：robert和john是男性
        public static Expression getMaleExpression(){
            Expression robert = new TerminalExpression("Robert");
            Expression john = new TerminalExpression("John");
            return new OrExpression(robert,john);
        }
    
        //规则：julie是一个已婚女性
        public static Expression getMarriedWomanExpression(){
            Expression julie =  new TerminalExpression("Julie");
            Expression married = new TerminalExpression("Married");
            return new AndExpression(julie,married);
        }
    
        public static void main(String[] args){
            Expression isMale = getMaleExpression();
            Expression isMarriedWoman = getMarriedWomanExpression();
    
            System.out.println("John is male?"+isMale.interpret("John"));
            System.out.println("Julie is a married women?"+isMarriedWoman.interpret("Married Julie"));
        }
    }

**执行程序，输出结果：**

John is male?true
    Julie is a married women?true

[watermark_type_ZmFuZ3poZW5naGVpdGk_shadow_10_text_aHR0cHM6Ly9ibG9nLmNzZG4ubmV0L2xpX3dfY2g_size_16_color_FFFFFF_t_70]: /images/20221120/a1e4876b6b5b4c7f865d39666e4f9e6b.png