解释器模式

四则运算问题

传统方案解决四则运算问题分析

 

 

 

解释器模式基本介绍

解释器模式的原理类图

 

 

 

对原理类图的说明-即（解释器模式的角色及职责）

解释器模式来实现四则运算

  1. 应用实例要求

通过解释器模式来实现四则运算

如：计算a+b-c 的值

　　2.思路分析和图解（类图）

 

 

　　3.代码实现

package com.sky.interpreter;

import java.util.HashMap;

/**
 * 抽象类表达式，通过hashmap 键值对，可以获取到变量的值
 */
public abstract class Expression {

    /**
     * a + b -c
     * 解释公式和数值，key就是公式（表达式） 参数[a,b,c], value 就是具体值
     * hashmap {a=10,b=20....}
     * @param var
     * @return
     */
    public abstract int interpreter(HashMap<String,Integer> var);
}
package com.sky.interpreter;

import java.util.HashMap;

/**
 * 抽象运算符号解释器，这里，每个运算符号，都只和自己左右两个数字有关系。
 * 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类
 */
public class SymbolExpression extends Expression{

    protected Expression left;
    protected Expression right;

    public SymbolExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    /**
     * 因为 SymbolExpression 是让其子类来实现，因此 interpreter 是一个默认实现
     * @param var
     * @return
     */
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return 0; // 这里是一个空实现
    }
}
package com.sky.interpreter;

import java.util.HashMap;

/**
 * 变量解释器
 */
public class VarExpression extends Expression {

    private String key; // key = a ,key = b, key = c

    // 构造器
    public VarExpression(String key) {
        this.key = key;
    }

    /**
     * var 就是 {a=10,b=20....}
     * interpreter() 方法 作用：根据变量名称，返回对应值。
     * @param var
     * @return
     */
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return var.get(this.key);
    }
}
package com.sky.interpreter;

import java.util.HashMap;

public class AddExpression extends SymbolExpression {

    public AddExpression(Expression left, Expression right) {
        super(left, right);
    }

    /**
     * 处理相加
     * var 仍然是 {a=10,b=20....}
     * super.left.interpreter(var) : 返回left 表达式对应的值 a=10
     * super.right.interpreter(var) : 返回right 表达式对应的值 b=10
     * @param var
     * @return
     */
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) + super.right.interpreter(var);
    }

}
package com.sky.interpreter;

import java.util.HashMap;

public class SubExpression extends SymbolExpression {

    public SubExpression(Expression left, Expression right) {
        super(left, right);
    }

    /**
     * 处理相减
     * var 仍然是 {a=10,b=20....}
     * super.left.interpreter(var) : 返回left 表达式对应的值 a=10
     * super.right.interpreter(var) : 返回right 表达式对应的值 b=10
     * @param var
     * @return
     */
    @Override
    public int interpreter(HashMap<String, Integer> var) {
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}
package com.sky.interpreter;

import java.util.HashMap;
import java.util.Stack;

/**
 * 计算器
 */
public class Calculator {

    // 定义表达式
    private Expression expression;

    // 构造函数传参，并解析
    public Calculator(String expStr) {

        //安排运算先后顺序
        Stack<Expression> stack = new Stack<>();
        char[] charArray = expStr.toCharArray(); // [a,+,b]

        Expression left = null;
        Expression right = null;
        // 遍历我们的字符数组,即遍历 [a,+,b] , 针对不同的情况，做不同的处理
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
                case '+':
                    left = stack.pop(); // 从stack取出left => 'a'
                    right = new VarExpression(String.valueOf(charArray[++i])); // 取出右表达式 'b'
                    stack.push(new AddExpression(left, right)); // 然后根据得到 left 和 right 构建 AddExpression 加入到 stack 中
                    break;
                case '-':
                    left = stack.pop();
                    right = new VarExpression(String.valueOf(charArray[++i])); //
                    stack.push(new SubExpression(left, right));
                    break;
                default:
                    // 如果是一个 var 就创建一个VarExpression对象，并 push 到 stack 中。
                    stack.push(new VarExpression(String.valueOf(charArray[i])));
                    break;
            }
        }
        // 当遍历完整个 charArray 数组后，stack 就得到最后的Expression
        this.expression = stack.pop();
    }

    public int run(HashMap<String, Integer> var){
        // 最后将表达式a+b 和 var = {a=10,b=20}
        // 然后传递给expression的interpreter方法进行解释执行
        return this.expression.interpreter(var);
    }

}
package com.sky.interpreter;

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

/**
 * 客户端
 */
public class ClientTest {

    public static void main(String[] args) throws Exception {
        String expStr = getExpStr(); // a+b
        HashMap<String, Integer> var = getValue(expStr); // var {a=10,b=20}
        Calculator calculator = new Calculator(expStr);
        System.out.println("运算结果：" + expStr + "=" + calculator.run(var));

    }

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

    // 获得值映射
    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)); // map.put('a',10) 这种样子的
                }

            }
        }
        return map;
    }
}

请输入表达式：a+b
请输入 a的值：10
请输入 b的值：20
运算结果：a+b=30

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

 

posted on 2022-12-19 09:36  ~码铃薯~  阅读(23)  评论(0)  编辑  收藏  举报

导航