读设计模式之禅--解释器模式

• 定义：给定一门语言，定义它的文法的一种表示，并定义一个解释器，该解释器使用该表示来解释语言中的句子

简言之：是一种按照规定语法进行解析的方案

package interpreter;

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

/**
 * @author hyh
 * @create 2021-08-29 10:42
 * 抽象一表达式
 */
public abstract class Expresion {

    // key  是参数   value 是值 如 a = 3
    public abstract int interpreter(HashMap<String, Integer> var);
}

class VarExpresion extends Expresion {

    private String key;

    public String getKey() {
        return key;
    }

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

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

abstract class SymbolExpresion extends Expresion {
    public Expresion left;
    public Expresion right;


    public SymbolExpresion(Expresion left, Expresion right) {
        this.left = left;
        this.right = right;
    }
}

class Add extends SymbolExpresion {


    public Add(Expresion left, Expresion right) {
        super(left, right);
    }

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

class Sub extends SymbolExpresion {

    public Sub(Expresion left, Expresion right) {
        super(left, right);
    }

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

class Calculator {

    private Expresion e;

    public Calculator(String expStr) {


        Stack<Expresion> s = new Stack<>();

        char[] chars = expStr.toCharArray();

        Expresion left;
        Expresion right;

        for (int i = 0; i < chars.length; i++) {

            switch (chars[i]) {
                case '+':
                    left = s.pop();
                    right = new VarExpresion(String.valueOf(chars[++i]));
                    s.push(new Add(left, right));
                    break;
                case '-':
                    left = s.pop();
                    right = new VarExpresion(String.valueOf(chars[++i]));
                    s.push(new Sub(left, right));
                    break;
                default:
                    s.push(new VarExpresion(String.valueOf(chars[i])));
            }
        }
        this.e = s.pop();
    }

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

}

class Client {

    public static void main(String[] args) throws IOException {

        String expStr = getExpStr();
        //赋值
        HashMap<String, Integer> var = getValue(expStr);

        Calculator calculator = new Calculator(expStr);
        int result = calculator.run(var);

        System.out.println(expStr + " 结果：" +result);

    }

    public static HashMap<String, Integer> getValue(String exprStr) 
    throws IOException {
        HashMap<String, Integer> map = new HashMap<>(16);
        //解析有几个参数要传递
        for (char ch : exprStr.toCharArray()) {
            if (ch != '+' && ch != '-') {
                //解决重复参数的问题
                if (!map.containsKey(String.valueOf(ch))) {
                    String in = (new BufferedReader(new 
                    InputStreamReader(System.in))).readLine();
                    map.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }
        return map;
    }


    private static String getExpStr() throws IOException {
        System.out.print("请输入表达式：");
        return (new BufferedReader(new InputStreamReader(System.in)))
        .readLine();
    }
}
输出：
请输入表达式：a+b+c
2
2
2
a+b+c 结果：6