java设计模式-解释器模式

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

意图：
给定一个语言，定义它的文法表示，并定义一个解释器，这个解释器使用该标识来解释语言中的句子。
主要解决：
对于一些固定文法构建一个解释句子的解释器。

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

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

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

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

优点：
1、可扩展性比较好，灵活。
2、增加了新的解释表达式的方式。
3、易于实现简单文法。
缺点：
1、可利用场景比较少。
2、对于复杂的文法比较难维护。
3、解释器模式会引起类膨胀。
4、解释器模式采用递归调用方法。

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

解释器模式包含以下主要角色：

1.抽象表达式（Abstract Expression）角色：定义解释器的接口，约定解释器的解释操作，主要包含解释方法 interpret()。

2.终结符表达式（Terminal Expression）角色：是抽象表达式的子类，用来实现文法中与终结符相关的操作，文法中的每一个终结符都有一个具体终结表达式与之相对应。

3.非终结符表达式（Nonterminal Expression）角色：也是抽象表达式的子类，用来实现文法中与非终结符相关的操作，文法中的每条规则都对应于一个非终结符表达式。

4.环境（Context）角色：通常包含各个解释器需要的数据或是公共的功能，一般用来传递被所有解释器共享的数据，后面的解释器可以从这里获取这些值。

5.客户端（Client）：主要任务是将需要分析的句子或表达式转换成使用解释器对象描述的抽象语法树，然后调用解释器的解释方法，当然也可以通过环境角色间接访问解释器的解释方法。

例如：北上广深的"老人", “小孩”, “残疾人”, "孕妇"可以免费坐地铁
类图：

实现：

package com.example.designmode.interpreter;

/**
 * <h3>design-mode</h3>
 * <p>抽象表达式</p>
 *
 * @author : ZhangYuJie
 * @date : 2022-06-05 13:17
 **/
public interface Expression {
    boolean interpret(String info);
}

package com.example.designmode.interpreter;

import java.util.HashSet;
import java.util.Set;

/**
 * <h3>design-mode</h3>
 * <p>终结符表达式</p>
 *
 * @author : ZhangYuJie
 * @date : 2022-06-05 13:18
 **/

public class TerminalExpression implements Expression {

    private Set<String> set = new HashSet<String>();

    public TerminalExpression(String[] data) {
        for (int i = 0; i < data.length; i++) {
            set.add(data[i]);
        }
    }

    /**
     * 对终结符表达式的处理
     * @param info
     * @return
     */
    @Override
    public boolean interpret(String info) {
        if (set.contains(info)) {
            return true;
        }
        return false;
    }
}

package com.example.designmode.interpreter;

/**
 * <h3>design-mode</h3>
 * <p>非终结符表达式类</p>
 *
 * @author : ZhangYuJie
 * @date : 2022-06-05 13:18
 **/

public class AndExpression implements Expression {
    private Expression city;
    private Expression person;

    public AndExpression(Expression city, Expression person) {
        this.city = city;
        this.person = person;
    }

    /**
     * 非对终结符表达式的处理
     * @param info
     * @return
     */
    @Override
    public boolean interpret(String info) {
        String s[] = info.split("的");
        //判断city是否包含存入的信息 && person是否包含存入的信息
        return city.interpret(s[0]) && person.interpret(s[1]);
    }

}

package com.example.designmode.interpreter;

/**
 * <h3>design-mode</h3>
 * <p>环境类</p>
 *
 * @author : ZhangYuJie
 * @date : 2022-06-05 13:19
 **/

public class Context {
    private String[] citys = {"上海", "北京", "广州", "深圳"};
    private String[] persons = {"老人", "小孩", "残疾人", "孕妇"};
    private Expression expression = null;

    public Context() {
        Expression city = new TerminalExpression(citys);
        Expression person = new TerminalExpression(persons);
        expression = new AndExpression(city, person);
    }

    //调用相关表达式类的解释方法
    public void freeRide(String info) {
        boolean ok = expression.interpret(info);
        if (ok) {
            System.out.println("您是" + info + "，您本次乘车免费！");
        } else {
            System.out.println(info + "，您不是免费人员，本次乘车扣费2元！");
        }
    }
}

package com.example.designmode.interpreter;

/**
 * <h3>design-mode</h3>
 * <p></p>
 *
 * @author : ZhangYuJie
 * @date : 2022-06-05 13:20
 **/

public class InterpreterTest {
    public static void main(String[] args) {
        Context bus = new Context();
        bus.freeRide("深圳的老人");
        bus.freeRide("上海的年轻人");
        bus.freeRide("北京的妇女");
        bus.freeRide("广州的小孩");
        bus.freeRide("山东的小孩");
    }

}

输出结果：
您是深圳的老人，您本次乘车免费！
上海的年轻人，您不是免费人员，本次乘车扣费2元！
北京的妇女，您不是免费人员，本次乘车扣费2元！
您是广州的小孩，您本次乘车免费！
山东的小孩，您不是免费人员，本次乘车扣费2元！