設計模式之解釋器模式

定義

給定一個語言，定義它的文法的一種表示，並定義一個解釋器，這個解釋器使用該表示來解釋語言中的句子。

爲了解釋一種語言，而爲語言創建的解釋器。

類型

行爲型

適用場景

①、某個特定類型問題發生頻率足夠高。

優缺點

優點：
①、語法由很多類表示，容易改變及擴展此“語言”。

缺點：
①、當語法規則數目太多時，增加了系統複雜度。

代碼實現

案例，利用棧來自定義一套加法和乘法的語法，來解釋某個字符串。
首先定義一個解釋器的接口

public interface Interpreter {

    int interpreter();
}

創建一個加法的解釋器

public class AddInterpreter implements Interpreter {

    private Interpreter firstExpression, secondExpression;

    public AddInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpreter() {
        return this.firstExpression.interpreter() + this.secondExpression.interpreter();
    }

    @Override
    public String toString() {
        return "+";
    }
}

再創建一個乘法的解釋器

public class MultiInterpreter implements Interpreter {

    private Interpreter firstExpression, secondExpression;

    public MultiInterpreter(Interpreter firstExpression, Interpreter secondExpression) {
        this.firstExpression = firstExpression;
        this.secondExpression = secondExpression;
    }

    @Override
    public int interpreter() {
        return this.firstExpression.interpreter() * this.secondExpression.interpreter();
    }

    @Override
    public String toString() {
        return "*";
    }
}

創建一個數字轉換的解釋器。

public class NumberInterpreter implements Interpreter {

    private int number;

    public NumberInterpreter(int number) {
        this.number = number;
    }

    public NumberInterpreter(String number) {
        this.number = Integer.parseInt(number);
    }

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

創建一個獲取當前解釋器類型的工具類

public class OperatorUtil {

    /**
     * 判斷是否可操作(+ 或者 *)
     */
    public static boolean isOperator(String symbol) {
        return (symbol.equals("+") || symbol.equals("*"));
    }

    public static Interpreter getExpressionObject(Interpreter firstExpression, Interpreter secondExpression, String symbol) {
        if (symbol.equals("+")) {
            return new AddInterpreter(firstExpression, secondExpression);
        } else if (symbol.equals("*")) {
            return new MultiInterpreter(firstExpression, secondExpression);
        }
        return null;
    }
}

最後開始進行表達式的解析

public class CustomerExpressionParser {

    /**
     * 聲明一個棧
     */
    private Stack<Interpreter> stack = new Stack<Interpreter>();

    public int parse(String str) {
        String[] strArray = str.split(" ");
        for (String symbol : strArray) {
            // 判斷當前字符是否可操作
            if (!OperatorUtil.isOperator(symbol)) {
                Interpreter numberExpression = new NumberInterpreter(symbol);
                // 入棧
                stack.push(numberExpression);
                System.out.println(String.format("入棧: %d", numberExpression.interpreter()));
            } else {
                // 是運算符,可以計算
                Interpreter firstExpression = stack.pop();
                Interpreter secondExpression = stack.pop();
                System.out.println(String.format("出棧: %d 和 %d", firstExpression.interpreter(), secondExpression.interpreter()));
                Interpreter operator = OperatorUtil.getExpressionObject(firstExpression, secondExpression, symbol);
                System.out.println(String.format("應用運算符: %s", operator));

                assert operator != null;
                int result = operator.interpreter();
                NumberInterpreter resultExpression = new NumberInterpreter(result);
                stack.push(resultExpression);
                System.out.println(String.format("階段結果入棧: %d", resultExpression.interpreter()));
            }
        }
        return stack.pop().interpreter();
    }
}

編寫測試類

public class MainTest {

    public static void main(String[] args) {
        String str = "6 100 11 + *";
        CustomerExpressionParser expressionParser = new CustomerExpressionParser();
        int result = expressionParser.parse(str);
        System.out.println("解釋器計算結果: " + result);
    }
}

輸出結果：

到此，自定義解釋器就完成了，在平時開發中，基本上不用自己創建解釋器。只是學習和理解這種設計模式。

相關源碼

1. Jdk中的Pattern正則表達式。
2. Spring中的EL表達式。

參考鏈接
https://coding.imooc.com/learn/list/270.html