淺談Java解釋器模式

更新時間：2021年10月14日 10:11:33 作者：KnightHONG

這篇文章主要介紹了Java基于解釋器模式實現(xiàn)定義一種簡單的語言功能,簡單描述了解釋器模式的概念、功能及Java使用解釋器模式定義一種簡單語言的相關(guān)實現(xiàn)與使用技巧,需要的朋友可以參考下

**請注意！請注意！??！**今天講給大家講解非常“有用”的設(shè)計模式，解釋器模式！?。?/p>

設(shè)計模式有三大種類，一種是創(chuàng)建型模式，一種是結(jié)構(gòu)型模式，最后一種是行為性模式，那么解釋器模式屬于哪一種呢？帶領(lǐng)大家一起來了解學(xué)習(xí)解釋器模式！

 本次介紹圍繞著以下五點展開。什么是解釋器模式？用來做什么？怎么做？有哪些優(yōu)點？有哪些不足？

解釋器模式顧名思義，就是用來定義和解釋。

給定一種特定語言，這個語言有特定的文法，解釋器可以解釋這個語言中的句子含義。即解釋器提供一種語言，如java，同時它也提供一種手段去解析java語言寫出來的代碼。

大家可能也會想到這就是類似編譯原理，一個算術(shù)表達(dá)式要經(jīng)過詞法分析，語法分析，構(gòu)建語法樹啥的；還有正則表達(dá)式；SQL解析，編譯器等等，其實都是解析式模式的一種實現(xiàn)。

那怎么做？一個是說要有像編譯原理中的終結(jié)符和非終結(jié)符，構(gòu)建一顆語法樹。同時需要有一個環(huán)境類，來管理輸入和輸出。

這里我們舉一個例子，輸入一個表達(dá)式a+b-c+d-e，同時給這5個變量賦值，計算出它的值。那么使用解釋器模式要如何實現(xiàn)？

我們?yōu)榻忉屍鞫x一個抽象解釋類Expression，所有的流轉(zhuǎn)通過interpreter方法實現(xiàn)。

上下文管理輸入輸出使用一個HashMap去實現(xiàn)。

定義符號解釋類SymbolExpression，加法解釋類AddExpreesion，減法解釋類SubExpression。

類圖：

在這里插入圖片描述

具體代碼實現(xiàn)：

public abstract class Expression {

    // map中攜帶了表達(dá)式中的變量名(key) 和 對應(yīng)的值(value)
    public abstract int interpreter(Map<String, Integer> var);

}

public class VarExpression extends Expression {

    // 表達(dá)式中對應(yīng)的變量名
    String key;

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

    @Override
    public int interpreter(Map<String, Integer> var) {
        return var.get(key);
    }
}

public class SymbolExpression extends Expression {

    // +或-符號 左右兩邊的表達(dá)式
    Expression var1;
    Expression var2;

    public SymbolExpression(Expression var1, Expression var2) {
        this.var1 = var1;
        this.var2 = var2;
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        // 實現(xiàn)抽象方法
        // 該類不需要用到該方法 默認(rèn)返回0
        return 0;
    }
}

public class AddExpression extends SymbolExpression {

    public AddExpression(Expression var1, Expression var2) {
        super(var1, var2);
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return var1.interpreter(var) + var2.interpreter(var);
    }
}

public class SubExpression extends SymbolExpression {

    public SubExpression(Expression var1, Expression var2) {
        super(var1, var2);
    }

    @Override
    public int interpreter(Map<String, Integer> var) {
        return var1.interpreter(var) - var2.interpreter(var);
    }

}

public class Calculator {

    // 表達(dá)式
    private Expression expression;

    // 解析出表達(dá)式
    public Calculator(String expStr) {
        Stack<Expression> stack = new Stack<>();
        Expression left, right = null;
        char[] expStrCharArray = expStr.toCharArray();

        for(int i = 0; i < expStrCharArray.length; i++) {
            switch (expStrCharArray[i]) {
                case '+':// 加法運算 獲取左邊表達(dá)式 右邊數(shù)值
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(expStrCharArray[++i]));
                    stack.push(new AddExpression(left, right));
                    break;
                case '-':// 減法運算 獲取左邊表達(dá)式 右邊數(shù)值
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(expStrCharArray[++i]));
                    stack.push(new SubExpression(left, right));
                    break;
                default:// 表達(dá)式中的變量
                    stack.push(new VarExpression(String.valueOf(expStrCharArray[i])));
                    break;
            }
        }
        // 最后會獲得被Expression包裝起來的一個表達(dá)式
        this.expression = stack.pop();
    }

    // 計算結(jié)果
    public int run(Map<String, Integer> var) {
        return this.expression.interpreter(var);
    }
}

public class Client {

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

    //獲得表達(dá)式
    public static String getExpStr() {
        return "a+b-c+d-e";
    }

    //獲得值映射
    public static HashMap<String, Integer> getValue(String expStr) throws IOException {
        HashMap<String, Integer> map = new HashMap<>();

        for(char ch : expStr.toCharArray()) {
            if(ch != '+' && ch != '-' ) {
                if(! map.containsKey(String.valueOf(ch))) {
                    System.out.print("請輸入" + String.valueOf(ch) + "的值：");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }

        return map;
    }

}

結(jié)果