深入Java設計模式之釋器模式

介紹

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

主要解決：對於一些固定文法構建一個解釋句子的解釋器。

何時使用：如果一種特定類型的問題發生的頻率足夠高，那麼可能就值得將該問題的各個實例表述爲一個簡單語言中的句子。這樣就可以構建一個解釋器，該解釋器通過解釋這些句子來解決該問題。

如何解決：構建語法樹，定義終結符與非終結符。

關鍵代碼：構建環境類，包含解釋器之外的一些全局信息，一般是 HashMap。

應用實例：編譯器、運算表達式計算。

優點： 1、可擴展性比較好，靈活。 2、增加了新的解釋表達式的方式。 3、易於實現簡單文法。

缺點： 1、可利用場景比較少。 2、對於複雜的文法比較難維護。 3、解釋器模式會引起類膨脹。 4、解釋器模式採用遞歸調用方法。

使用場景： 1、可以將一個需要解釋執行的語言中的句子表示爲一個抽象語法樹。 2、一些重複出現的問題可以用一種簡單的語言來進行表達。 3、一個簡單語法需要解釋的場景。

注意事項：可利用場景比較少，JAVA 中如果碰到可以用 expression4J 代替。

 案例

package com.lzhsite.technology.designPattern.Interpreter.FinanceDemo;

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.HashMap;

public class ClientForFinanceDemo
{
    public static void main(String[] args)
    {
        String expStr = getExpStr();
        HashMap<String, Integer> var = getValue(expStr);
        Calculator calculator = new Calculator(expStr);
        System.out.println("運算結果爲：" + expStr + " = " + calculator.run(var));
    }

    public static String getExpStr()
    {
        String in = null;
        System.out.println("請輸入表達式：");
        try
        {
            in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
        } catch (IOException exception)
        {
            exception.printStackTrace();
        }
        return in;
    }

    public static HashMap<String, Integer> getValue(String expStr)
    {
        String in = null;
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        for (char ch : expStr.toCharArray())
        {
            if (ch != '+' && ch != '-')
            {
                if (!map.containsKey(String.valueOf(ch)))
                {
                    System.out.print("請輸入" + ch + "的值：");
                    try
                    {
                        in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    } catch (IOException exception)
                    {
                        exception.printStackTrace();
                    }
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }
        return map;
    }
}

 

package com.lzhsite.technology.designPattern.Interpreter.FinanceDemo;

import java.util.HashMap;
import java.util.Stack;

public class Calculator
{
    private Expression expression;

    public Calculator(String expStr)
    {
        Stack<Expression> stack = new Stack<Expression>();
        char[] charArray = expStr.toCharArray();

        Expression left = null;
        Expression right = null;

        for (int i = 0; i < charArray.length; i++)
        {
            switch (charArray[i])
            {
                case '+':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new AddExpression(left, right));
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
            }
        }
        this.expression = stack.pop();
    }

    public int run(HashMap<String, Integer> var)
    {
        return this.expression.interpreter(var);
    }
}

 表達式接口

package com.lzhsite.technology.designPattern.Interpreter.FinanceDemo;

import java.util.HashMap;

public abstract class Expression
{
    public abstract int interpreter(HashMap<String, Integer> var);
}

運算符號 

package com.lzhsite.technology.designPattern.Interpreter.FinanceDemo;

public abstract class SymbolExpression extends Expression
{
    protected Expression left;
    protected Expression right;

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

package com.lzhsite.technology.designPattern.Interpreter.FinanceDemo;

import java.util.HashMap;

public class SubExpression extends SymbolExpression
{
    public SubExpression(Expression left, Expression right)
    {
        super(left, right);
    }

    public int interpreter(HashMap<String, Integer> var)
    {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}

變量 

package com.lzhsite.technology.designPattern.Interpreter.FinanceDemo;

import java.util.HashMap;

public class VarExpression extends Expression
{
    private String key;

    public VarExpression(String key)
    {
        this.key = key;
    }

    public int interpreter(HashMap<String, Integer> var)
    {
        return var.get(this.key);
    }
}

示例代碼：

https://gitee.com/lzhcode/maven-parent/tree/master/lzh-technology/src/main/java/com/lzhsite/technology/designPattern/Interpreter/FinanceDemo