共计 2687 个字符，预计需要花费 7 分钟才能阅读完成。

解释器模式

概述

 解释器（Interpreter Pattern）模式：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。

在实际开发中几乎不需要自定义解释器，一个完整的解释器模式是十分复杂的。

概述

 解释器模式属于行为型模式。

介绍

• 目的：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子。
• 主要解决：对于一些固定文法构建一个解释句子的解释器。
• 使用场景：如果一种特定类型的问题发生的频率足够高，那么可能就值得将该问题的各个实例表述为一个简单语言中的句子。这样就可以构建一个解释器，该解释器通过解释这些句子来解决该问题。

示例代码

 因为一个完整的解释器模式比较复杂，因此这里选择汉语的十以内加减法的实现。例如输入"一加一"，则会输出2等。

Expression接口

 Expression定义了表达式的相关接口，这里定义了一个解释方法，它会返回表达式的解释结果。

package interpreter;

public interface Expression {
    int interpreter();
}

Number类

 Number是数字类的具体解释类，它会将十以内的汉字转换为阿拉伯数字。

package interpreter;

public class Number implements Expression{
    private int number;

    public Number(char word){
        switch (word) {
            case '零':
                number = 0;
                break;
            case '一':
                number = 1;
                break;
            case '二':
                number = 2;
                break;
            case '三':
                number = 3;
                break;
            case '四':
                number = 4;
                break;
            case '五':
                number = 5;
                break;
            case '六':
                number = 6;
                break;
            case '七':
                number = 7;
                break;
            case '八':
                number = 8;
                break;
            case '九':
                number = 9;
                break;
            default:
                break;
        }
    }

    @Override
    public int interpreter() {
        return number;
    }
}

Operator抽象类

 Operator抽象类用于定义加减操作的相同部分，对于加减运算，依据运算符进行划分，它有左边和右边两个字符。

package interpreter;

public abstract class Operator implements Expression {
    Expression left;
    Expression right;
    Operator(Expression left,Expression right){
        this.left = left;
        this.right = right;
    }
}

Add类

 Add类是加法的具体解释类。它实现了汉语加法运算。

package interpreter;

public class Add extends Operator{
    Add(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() + right.interpreter();
    }
}

Sub类

 Sub类是减法的具体解释类。它实现了汉语减法运算。

package interpreter;

public class Sub extends Operator{
    Sub(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public int interpreter() {
        return left.interpreter() - right.interpreter();
    }
}

Calculator类

 Calculator是计算类，它实现了基于Add和Sub的复杂计算操作。实现操作使用了栈这一数据结构。

package interpreter;

import java.util.Stack;

public class Calculator {
    public int calculator(String expression){
        Stack<Expression> stack = new Stack<>();
        for (int i = 0; i < expression.length(); i++) {
            char word = expression.charAt(i);
            switch (word){
                case '加':
                    stack.push(new Add(stack.pop(),new Number(expression.charAt(++i))));
                    break;
                case '减':
                    stack.push(new Sub(stack.pop(),new Number(expression.charAt(++i))));
                    break;
                default:
                    stack.push(new Number(word));
                    break;
            }
        }
        return stack.pop().interpreter();
    }
}

 测试代码及运行结果如下：

package interpreter;

import org.junit.Test;

public class InterpreterTest {
    @Test
    public void interpreterTest(){
        String expression1 = "一加一";
        String expression2 = "四加二减一";
        Calculator calculator = new Calculator();
        int calculator1 = calculator.calculator(expression1);
        int calculator2 = calculator.calculator(expression2);
        System.out.println(expression1 + "等于" + calculator1);
        System.out.println(expression2 + "等于" + calculator2);
    }
}

一加一等于2
四加二减一等于5

其它

 解释器模式的可利用场景比较少，JAVA 中如果碰到可以用 expression4J 代替。