设计模式解释器模式

解释器模式的定义

解释器模式 (Interpreter Pattern)：定义一个语言的文法，并且建立一个解释器来解释该语言中的句子，这里的 “语言” 是指使用规定格式和语法的代码。解释器模式是一种类行为型模式。

由于表达式可分为终结符表达式和非终结符表达式，因此解释器模式的结构与组合模式的结构有些类似，但在解释器模式中包含更多的组成元素。

设计模式之解释器模式

解释器模式用于描述如何使用面向对象语言构成一个简单的语言解释器。在某些情况下，为了更好地描述某一些特定类型的问题，我们可以创建一种新的语言，这种语言拥有自己的表达式和结构，即文法规则，这些问题的实例将对应为该语言中的句子。此时，可以使用解释器模式来设计这种新的语言。对解释器模式的学习能够加深我们对面向对象思想的理解，并且掌握编程语言中文法规则的解释过程。

解释器模式总结

解释器模式为自定义语言的设计和实现提供了一种解决方案，它用于定义一组文法规则并通过这组文法规则来解释语言中的句子。虽然解释器模式的使用频率不是特别高，但是它在正则表达式、XML 文档解释等领域还是得到了广泛使用。与解释器模式类似，目前还诞生了很多基于抽象语法树的源代码处理工具，例如 Eclipse 中的 Eclipse AST，它可以用于表示 Java 语言的语法结构，用户可以通过扩展其功能，创建自己的文法规则。

解释器模式的主要优点如下：

易于改变和扩展文法。由于在解释器模式中使用类来表示语言的文法规则，因此可以通过继承等机制来改变或扩展文法。

每一条文法规则都可以表示为一个类，因此可以方便地实现一个简单的语言。

实现文法较为容易。在抽象语法树中每一个表达式节点类的实现方式都是相似的，这些类的代码编写都不会特别复杂，还可以通过一些工具自动生成节点类代码。

增加新的解释表达式较为方便。如果用户需要增加新的解释表达式只需要对应增加一个新的终结符表达式或非终结符表达式类，原有表达式类代码无须修改，符合 “开闭原则”。

解释器模式的主要缺点如下：

对于复杂文法难以维护。在解释器模式中，每一条规则至少需要定义一个类，因此如果一个语言包含太多文法规则，类的个数将会急剧增加，导致系统难以管理和维护，此时可以考虑使用语法分析程序等方式来取代解释器模式。

执行效率较低。由于在解释器模式中使用了大量的循环和递归调用，因此在解释较为复杂的句子时其速度很慢，而且代码的调试过程也比较麻烦。

适用场景

在以下情况下可以考虑使用解释器模式：

可以将一个需要解释执行的语言中的句子表示为一个抽象语法树。

一些重复出现的问题可以用一种简单的语言来进行表达。

一个语言的文法较为简单。

执行效率不是关键问题。【注：高效的解释器通常不是通过直接解释抽象语法树来实现的，而是需要将它们转换成其他形式，使用解释器模式的执行效率并不高。】

Java 实例代码：

import java.util.*;

public class InterpreterPattern {

    public static void main(String[] args) {

        Context context = new Context();

        context.check("A区的开发人员");

        context.check("B区的调试人员");

        context.check("C区的测试人员");

        System.out.println("==========");

        context.check("D区的程序员");

        context.check("D区的测试员");

        context.check("A区的程序员");

    }

}

class Context {

    private String[] regions = {"A区", "B区", "C区"};

    private String[] persons = {"开发人员", "测试人员", "调试人员"};

    private NonterminalExprssion nonterminal;

    public Context() {

        TerminalExpression region = new TerminalExpression(regions);

        TerminalExpression person = new TerminalExpression(persons);

        nonterminal = new NonterminalExprssion(region, person);

    }

    public void check(String info) {

        boolean bool = nonterminal.Interpret(info);

        if (bool) {

            System.out.println("识别成功");

        } else {

            System.out.println("识别失败");

        }

    }

}

interface Expression {

    public boolean Interpret(String info);

}

class NonterminalExprssion implements Expression {

    private TerminalExpression region;

    private TerminalExpression person;

    public NonterminalExprssion(TerminalExpression region, TerminalExpression person) {

        this.region = region;

        this.person = person;

    }

    @Override

    public boolean Interpret(String info) {

        String[] str = info.split("的");

        // B区的调试人员 --> str = {"B区", "调试人员"}

        return region.Interpret(str[0]) && person.Interpret(str[1]);

    }

}

class TerminalExpression implements Expression {

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

    public TerminalExpression(String[] data) {

        // for (遍历对象类型 对象名 : 遍历对象)

        for (String str : data) {

            set.add(str);

        }

    }

    @Override

    public boolean Interpret(String info) {

        return set.contains(info);

    }

}