Java大数据平台开发 学习笔记（52）—— java设计模式（解释器模式）知识汇总

一、前言：

解释器模式的注意事项和细节：

1. 当有一个语言需要解释运行，可将该语言中的句子表示成一个抽象语法树，就可以考虑使用解释器模式，让程序更具有扩展性。
2. 解释器模式采用递归调用方式，可能导致调试困难。

---

二、解释器模式：

2.1、UML 图：

2.2、代码实例：

Step 1) 创建 Express 抽象类：

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

Step 2) 创建 SymbolExpress 实现类：

public class SymbolExpress extends Express{
    protected Express left;
    protected Express right;

    public SymbolExpress(Express left, Express right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return 0;
    }
}

Step 3) 创建 VarExpress 抽象类：

public class VarExpress extends Express{
    private String key;

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

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

Step 4) 创建 AddExpress 实现类：

public class AddExpress extends SymbolExpress{
    public AddExpress(Express left, Express right){
        super(left, right);
    }

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

Step 5) 创建 SubExpress 实现类：

public class SubExpress extends SymbolExpress{
    public SubExpress(Express left, Express right){
        super(left,right);
    }

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

Step 6) 创建 Calculator 类：

public class Calculator {
    private Express express;

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

        Express left = null;
        Express right = null;

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

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

Step 7) 创建 main 方法：

public class ClientTest {
    public static void main(String[] args) throws IOException {
        String expStr = getExpStr();
        HashMap<String,Integer> var = getCalue(expStr);
        Calculator calculator = new Calculator(expStr);
        System.out.println("运算结果："+expStr+ "=" +calculator.run(var));
    }

    public static String getExpStr() throws IOException {
        System.out.println("请输入表达式：");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    public static HashMap<String,Integer> getCalue(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.println("请输入"+String.valueOf(ch) + "的值：");
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.parseInt(in));
                }
            }
        }
        return map;
    }
}

---

• 由 ChiKong_Tam 写于 2020 年 10 月 23 日