解析器模式是一種行為型設計模式。其思想是：給定一個語言, 定義它的文法的一種表示，並定義一個直譯器，該直譯器使用該表示來解釋語言中的句子。

解析器模式涉及4個角色：

• 抽象表示式（Expression）：宣告一個所有的具體表達式的抽象介面，包含一個interpret()方法，稱做解釋操作。
• 終結符表示式（Terminal Expression）： 實現與文法中的元素相關聯的解釋操作。通常一個直譯器模式中只有一個終結符表示式，但有多個例項，對應不同的終結符。例如表示式a+b中，+就是一個終結符。
• 非終結符表示式（Nonterminal Expression）：文法中的每一條規則都需要一個具體的非終結符表示式，非終結符表示式一般是文法中的運算子或者其他關鍵字。例如表示式a+b
  中，a和b就是非終結符。
• 環境（Context）：用來存放文法中各個終結符所對應的具體值，很多情況下我們使用Map來充當環境角色。

結構圖：   （圖片來源於網路）

下面提供一個簡單例子。一個簡易的控制檯計算器，要求使用者輸入一個表示式，如a+b-c，然後要求使用者輸入每個變數的具體值，如a=1，b=2，c=3，最後螢幕顯示計算結果。篇幅所限，這裡只演示加法和減法運算，有興趣的讀者可以自行擴充套件。

抽象表示式：

public interface Expression {
    double interpreter(HashMap<String, Double> var); // 宣告一個解析操作
}
 

非終結符表示式：

public class VarExp implements Expression {
    private String value;

    public VarExp(String value) {
        this.value = value;
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return var.get(this.value); // 返回表示式所對應的值
    }
}

終結符表示式：

public abstract class SymbolExp implements Expression {
    protected Expression left;  // 運算子左側的表示式
    protected Expression right; // 運算子右側的表示式

    public SymbolExp(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
}

// 加法
public class Add extends SymbolExp {
    public Add(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return left.interpreter(var) + right.interpreter(var); // 返回左右兩個表示式之和
    }
}

// 減法
public class Minus extends  SymbolExp {
    public Minus(Expression left, Expression right) {
        super(left, right);
    }

    @Override
    public double interpreter(HashMap<String, Double> var) {
        return left.interpreter(var) - right.interpreter(var); // 返回左右兩個表示式之差
    }
}
 

計算器：

public class Calculator {
    private Expression expression;

    public Calculator(String exp) {
        Expression left;
        Expression right;
        Stack<Expression> stack = new Stack<>();
        char[] chars = exp.toCharArray();
        for (int i = 0, len = chars.length; i < len; i++) {
            switch (chars[i]) {
                case '+':
                    left = stack.pop();                             // 從棧中取回上一個壓入的元素作為左側表示式
                    right = new VarExp(String.valueOf(chars[++i])); // 指標後移一位得到右側表示式
                    stack.push(new Add(left, right));               // 將計算結果壓回棧中
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExp(String.valueOf(chars[++i]));
                    stack.push(new Minus(left, right));
                    break;
                default:
                    // 如果是非運算子，則生成一個非終結表示式，然後壓和棧中
                    stack.push(new VarExp(String.valueOf(chars[i]))); 
                    break;
            }
        }
        this.expression = stack.pop(); // 遍歷完成後取回棧中的元素
    }

    // 實際上，計算已經在構造器裡完成了，這裡只是取回結果的值
    public double cal(HashMap<String, Double> var) {
        return this.expression.interpreter(var);
    }
}

客戶：

public class Client {
    // 執行程式
    public void run() {
        String exp = getExp();
        HashMap<String, Double> var = getValues(exp);
        Calculator calculator = new Calculator(exp);
        System.out.printf("%s = %f", exp, calculator.cal(var));
    }

    // 要求使用者輸入表示式
    private String getExp() {
        Scanner sc = new Scanner(System.in);
        System.out.println("please defined an expression:");
        return sc.nextLine();
    }

    // 要求使用者輸入每個變數的值
    private HashMap<String, Double> getValues(String exp) {
        HashMap<String, Double> map = new HashMap<>();
        Scanner sc = new Scanner(System.in);
        char[] chars = exp.toCharArray();
        for (char c : chars) {
            String str = String.valueOf(c);
            if (!"+-".contains(str) && !map.containsKey(str)) {
                System.out.printf("%s = ", str);
                map.put(str, sc.nextDouble());
            }
        }
        return map;
    }
}

// 測試
class Test {
    public static void main(String[] args) {
        Client client = new Client();
        client.run();
    }
}

執行結果：

please defined an expression:  a+b-c+b  a = 3  b = 2  c = 1  a+b-c+b = 6.000000

直譯器是一個簡單語法分析工具，它最顯著的優點就是擴充套件性，修改語法規則只要修改相應的非終結符表示式就可以了，若擴充套件語法，則只要增加非終結符類就可以了。

但是，直譯器模式由於使用了大量的迴圈和遞迴，效率是個不容忽視的問題，特別是用於解析複雜、冗長的語法時，效率是難以忍受的，排錯也非常困難。

直譯器模式在實際的系統開發中使用的非常少，因為它會引起效率、效能以及維護等問題，一般在大中型的框架型專案能夠找到它的身影，比如一些資料分析工具、報表設計工具、科學計算工具等等。當確實需要使用直譯器模式時，可以考慮使用Expression4J、MESP（Math Expression String Parser）、Jep等開源的解析工具包。