設計模式-解釋器模式

四則運算

模型公式，輸入一個公式，然後輸入其中的參數，然後運算出結果

代碼如下

抽象表達式類

public abstract class Expression{
    // 解析數值,key是參數，value是數字
    public abstract int interpreter(HashMap<String, Integer> var);
}           

變量解析器,根據此，可以獲得儲存在map中的鍵值對

public class VarExpress extends Expression{
    private String key;
    public VarExpression(String _key){
        this.key = _key;
    }
    // map取
    public int interpreter(HashMap<String, Integer> var){
        return var.get(this.key);
    }
}           

抽象運算符号解析器

public abstract class SymbolExpression extends Expression{
    // 左數值
    protected Expression left;
    // 右數值
    protected Expression right;
    // 初始化
    public SymbolExpression(Expression _left, Expression _right){
        this.left = _left;
        this.right = _right;
    }
}           

對加法進行解析

public class AddExpression extends SymbolExpression{
    public AddExpression(Expression _left, Expression _right){
        super(_left, _right);
    }
    // 進行相加
    public int interpreter(HashMap<String, Integer> var){
        // 取得，兩邊的變量都儲存在HashMap表中，根據left和right變量，進行相加
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
    // 進行相減
    public int interpreter(HashMap<String,Integer> var){
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}           

再次對解析器進行封裝,此為公式

public class Calculator{
    // 定義表達式
    private Expression expression;
    // 傳參
    public Calculator(String expStr){
        // 用于先後順序
        Stack stack = new Stack();
        // 将表達式拆分
        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(chrArray[++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.value(charArray[i])));
            }
        }
        // 運算結果抛出
        this.expression = stack.pop();
    }
    // 運算
    public int run(HashMap<String, Integer> var){
        return this.expression.interpreter(var);
    }
}           

在上方中，完成的是對表達式的輸入

最後場景

public class Client{
    public static void main(String[] args) throws IOException{
        String expStr = getExpStr();
        // 指派
        HashMap<String, Integer> var = getValue(expStr);
        Calculator cal = new Calculator(expStr);
        System.out.println("運算");
    }
    // 獲得表達式
    public static String getExpStr() throws IOException{
        // 建立一個緩沖區，從緩沖區中讀取資料
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }
    // 獲得值映射
    public static HashMap<String, Integer> getValue(String expStr) throws IOException{
        HashMap<String, Integer> map = new HashMap<String, Integer>();
        // 解析
        for(char ch:exprStr.toCharArray()){
            if(ch != '+' && != '-'){
                if(!map.containsKey(String.valueOf(ch))){
                    // 從緩沖區中，讀取整行
                    String in = (new BufferReader(new InputStreamReader(System.in))).readLine();
                }
            }
        }
        return map;
    }
}           

總結

解釋器模式不難，核心思想在于建構文法樹，進行運算的時候，進行遞歸調用。

具體做法是建立幾個解釋器，在建立一個解釋器封裝類，在解釋器封裝類中完成文法樹的建構。然後在場景類中完成遞歸調用。