设计模式（行为型设计模式——解释器模式）

设计模式（行为型设计模式——解释器模式）

解释器模式

基本定义

给分析对象定义一个语言，并定义该语言的文法表示，设计一个解析器来解释语言中的句子。

模式结构

• AbstractExpression：抽象表达式。声明一个抽象的解释操作，该接口为抽象语法树中所有的节点共享。

• TerminalExpression：终结符表达式。现与文法中的终结符相关的解释操作。实现抽象表达式中所要求的方法。解释结果。

• NonterminalExpression：非终结符表达式。为文法中的非终结符相关的解释操作。一般情况下以子类的形式出现。

• Context：环境类。包含解释器之外的一些全局信息。

• Client: 客户端类

代码实现

AbstractExpression：抽象解释器

public interface Node {
    int interpreter();
}
1
2
3

TerminalExpression：终结符表达式

/**
* 返回最终值
*/
public class ValueNode implements Node {


    private int value;


    public ValueNode(int value) {
        this.value = value;
    }


    @Override
    public int interpreter() {
        return this.value;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19

NonterminalExpression：非终结符表达式

public class SymbolNode implements Node{

    Node left;
    Node right;

    public SymbolNode(Node left, Node right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter() {
        return 0;
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15

/**
* 加法
*/
public class AddNode extends SymbolNode {

    public AddNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() + right.interpreter();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
* 减法
*/
public class SubtractNode extends SymbolNode {

    public SubtractNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() - right.interpreter();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
* 乘法
*/
public class MulNode extends SymbolNode {

    public MulNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() * right.interpreter();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

/**
* 除法
*/
public class DivisionNode extends SymbolNode {

    public DivisionNode(Node left, Node right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() / left.interpreter();
    }
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14

Context：环境类

public class Calculator {


    private Node node;


    private String statement;


    public void build(String statement){
        Node left = null;
        Node right = null;
        //提供容器，存储关系
        Stack stack = new Stack();
        //重点，将node存入stack, 存储前需确认表达式的顺序和执行结果
        //以空格分隔
        String[] statementArr = statement.split(" ");
        int index = 0;
        int value;
        for (String state : statementArr){
            index++;
            switch (state){
                case "*" ://乘法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new MulNode(left, right));
                    break;


                case "/" : //除法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new DivisionNode(left, right));
                    break;
                    
                case "+" : //加法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new AddNode(left, right));
                    break;


                case "-" : //减法
                    left = (Node)stack.pop();
                    value = Integer.parseInt(statementArr[index]);
                    right = new ValueNode(value);
                    stack.push(new SubtractNode(left, right));
                    break;


                default:
                    stack.push(new ValueNode(Integer.parseInt(state)));
                    break;
            }


        }
        //stack pop显示栈顶元素并且移除栈顶元素
        this.node = (Node) stack.pop();
    }


    public int compute(){
        return node.interpreter();
    }


}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71

Client: 客户端类

@Slf4j
public class Test {
    public static void main(String[] args){
    //约定以空格分割
        String statement = "3 * 2 / 2 + 1 - 2";
        Calculator calculator = new Calculator();
        calculator.build(statement);
        int result = calculator.compute();
        log.info("statement : {} ------> value = {}", statement, result);
    }
}
1
2
3
4
5
6
7
8
9
10
11

优点

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

• 容易实现。在语法树中的每个表达式节点类都是相似的，所以实现其文法较为容易

缺点

• 执行效率比较低，可利用场景比较少。

• 解释器模式中的每条规则至少需要定义一个类，当包含的文法规则很多时，类的个数将急剧增加，导致系统难以管理与维护。

• 可应用的场景比较少。在软件开发中，需要定义语言文法的应用实例非常少，所以这种模式很少被使用到。

使用场景

• 当一个语言需要解释执行，并且语言中的句子可以表示为一个抽象语法树的时候，如 XML 文档解释。

• 当问题重复出现，且可以用一种简单的语言来进行表达时。

• 当语言的文法较为简单，且执行效率不是关键问题时。

模式总结

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

• 虽然解释器的可扩展性强，但是如果语法规则的数目太大的时候，该模式可能就会变得异常复杂。所以解释器模式适用于文法较为简单的。