尚硅谷设计模式学习(21)---[解释器模式(Interpreter Pattern)]

尚硅谷传送门==>B站尚硅谷Java设计模式

❤❤❤感谢尚硅谷❤❤❤

最近开始计划学习一下设计模式了,加油!!!

---

解释器模式

给定语言(表达式)，定义它的表示，并定义解释器，使用该解释器来解释语言中的句子(表达式).

Context可以包含解释器之外的其他数据信息.

缺点:解释器模式会引起类膨胀;采用递归调用方法，将会导致调试非常复杂;效率降低

---

简易计算器案例

抽象的表达式类AbstractExpression

/**
 * @author by 优快云@小智RE0
 */

//抽象表达式;
public abstract class AbstractExpression {
    //解释;  公式的键值;
    public abstract int interpret(HashMap<String,Integer> varEle);
}

变量表达式TerminalExpression

/**
 * @author by 优快云@小智RE0
 */

//终结表达式;   变量表达式
public class TerminalExpression extends AbstractExpression {
    //公式的参数;例如a,b,c,d,e;
    private String varKey;

    //初始化;
    public TerminalExpression(String varKey) {
        this.varKey = varKey;
    }

    //获取到存入变量对应的数值;
    @Override
    public int interpret(HashMap<String, Integer> varEle) {
        return varEle.get(this.varKey);
    }
}

字符表达式NoTerminalExpression

/**
 * @author by 优快云@小智RE0
 */

//非终结表达式;   符号表达式;
public class NoTerminalExpression extends AbstractExpression{

    //每个运算符号两边都有数值;
    protected AbstractExpression left;
    protected AbstractExpression right;

    //初始化;
    public NoTerminalExpression(AbstractExpression left, AbstractExpression right) {
        this.left = left;
        this.right = right;
    }


    //这里是空实现,具体的让子类,加法/减法表达式去做;
    @Override
    public int interpret(HashMap<String, Integer> varEle) {
        return 0;
    }
}

加法字符的运算表达式AddExpression

/**
 * @author by 优快云@小智RE0
 */

//加法表达式;
public class AddExpression extends NoTerminalExpression{
    //初始化
    public AddExpression(AbstractExpression left, AbstractExpression right) {
        super(left, right);
    }

    //加法解释;  让左右两边的数值相加;
    @Override
    public int interpret(HashMap<String, Integer> varEle) {
        return super.left.interpret(varEle) + super.right.interpret(varEle);
    }
}

减法字符的运算表达式RemoveExpression

/**
 * @author by 优快云@小智RE0
 */
//减法表达式
public class RemoveExpression extends NoTerminalExpression{

    //初始化;
    public RemoveExpression(AbstractExpression left, AbstractExpression right) {
        super(left, right);
    }

    //减法解释; 让两边的数值相减;
    @Override
    public int interpret(HashMap<String, Integer> varEle) {
        return super.left.interpret(varEle) - super.right.interpret(varEle);
    }
}

计算器Calculator

/**
 * @author by 优快云@小智RE0
 */

//计算器;
public class Calculator {
    //表达式;
    private AbstractExpression abstractExpression;

    public Calculator(String str) {
        //定义运算顺序;
        Stack<AbstractExpression> stack = new Stack<AbstractExpression>();
        char[] c = str.toCharArray();

        //左右符号;
        AbstractExpression left = null;
        AbstractExpression right = null;

        for (int i = 0; i < c.length; i++) {
            switch (c[i]){
                case '+':
                    //左边的数字先入栈;
                    left=stack.pop();
                    //右边的入栈;
                    right=new TerminalExpression(String.valueOf(c[++i]));
                    //出栈加法运算;
                    stack.push(new AddExpression(left,right));
                    break;
                case '-':
                    //左边的数字先入栈;
                    left=stack.pop();
                    //右边的入栈;
                    right=new TerminalExpression(String.valueOf(c[++i]));
                    //出栈减法运算;
                    stack.push(new RemoveExpression(left,right));
                    break;
                default:
                    //不是加减符号的,就是变量了,直接出栈,
                    stack.push(new TerminalExpression(String.valueOf(c[i])));
                    break;
            }
        }
        this.abstractExpression = stack.pop();
    }

    //运行计算;
    public int show(HashMap<String,Integer> var){
        System.out.print("计算结果为==>");
        return this.abstractExpression.interpret(var);
    }
}

模拟客户端Client

/**
 * @author by 优快云@小智RE0
 */
//客户端;
public class Client {

    //输入表达式
    public static String input() throws IOException {
        System.out.println("输入运算的式子-->");
        return (new BufferedReader(new InputStreamReader(System.in))).readLine();
    }

    //表达式存入map集合后;
    public static  HashMap<String ,Integer> toMap(String str) throws IOException {
        HashMap<String ,Integer> hashMap = new HashMap<String, Integer>();
        for (char ch : str.toCharArray()) {
            if (ch != '+' && ch != '-') {
                if (!hashMap.containsKey(String.valueOf(ch))) {
                    System.out.print("输入当前变量" + String.valueOf(ch) + "值==>");
                    //为单个变量赋值;
                    String in = (new BufferedReader(new InputStreamReader(System.in))).readLine();
                    hashMap.put(String.valueOf(ch), Integer.valueOf(in));
                }
            }
        }
        return hashMap;
    }


    public static void main(String[] args) throws IOException {
        //先获取输入的运算表达式;
        String str =input();
        HashMap<String, Integer> hashMap = toMap(str);
        //使用计算器;
        Calculator calculator = new Calculator(str);
        //得到计算结果;
        System.out.println(calculator.show(hashMap));
    }
}

测试输出

输入运算的式子-->
a+b+v-p+o
输入变量a值==>10
输入变量b值==>12
输入变量v值==>6
输入变量p值==>32
输入变量o值==>20
计算结果为==>16

---