设计模式之解释器模式

四则运算问题

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

解释器模式基本介绍

原理类图

解释器模式实现四则

思路分析和图解

代码实现

/**
 * 抽象运算符号解析器 这里，每个运算符号都只和自己左右两个数字有关系，
 *  * 但左右两个数字有可能也是一个解析的结果，无论何种类型，都是Expression类的实现类
 * @author Administrator
 *
 */
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) {
		// TODO Auto-generated method stub
		return 0;
	}
}

/**
 * 加法解释器
 */
public class AddExpression extends SymbolExpression  {

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


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

public class SubExpression extends SymbolExpression {

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

	/**
	 * 求出left 和right 表达式相减后的结果
	 * @param var
	 * @return
	 */
	@Override
	public int interpreter(HashMap<String, Integer> var) {
		return super.left.interpreter(var) - super.right.interpreter(var);
	}
}

/**
 * 变量的解释器
 */

public class VarExpression extends Expression {

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

	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);
	}
}

/**
 * 抽象类表达式，通过HashMap 键值对 可以获取到各个变量值
 *
 * @author admin
 */

public abstract class Expression {


	/**
	 * 解释公式和数值 key/就是公式(表达式) value就是具体值
	 *
	 * {a=10,b=20}
	 * @param var
	 * @return
	 */
	public abstract int interpreter(HashMap<String, Integer> var);
}

public class Calculator {

	/**
	 * 定义表达式
	 */
	private Expression expression;

	/**
	 * 构造函数传参 并解析
	 * @param expStr
	 */
	public Calculator(String expStr) {
		//expStr = a+b
		// 安排运算先后顺序
		Stack<Expression> stack = new Stack<>();
		//表达式拆分成字符数组  [a,+,b]
		char[] charArray = expStr.toCharArray();

		Expression left = null;
		Expression right = null;
		//遍历字符数组
		//针对不同情况做处理
		for (int i = 0; i < charArray.length; i++) {
			switch (charArray[i]) {
			case '+':
				//从stack取出left "a"
				left = stack.pop();
				//取出右边表达式 "b"
				right = new VarExpression(String.valueOf(charArray[++i]));
				//根据left和right构建AddExpresson加入stack
				stack.push(new AddExpression(left, right));//
				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数组后  栈中就得到最后的Expression
		this.expression = stack.pop();
	}

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

public class ClientTest {

	public static void main(String[] args) throws IOException {
		// TODO Auto-generated method stub
		String expStr = getExpStr(); 
		HashMap<String, Integer> var = getValue(expStr);
		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));
				}
			}
		}

		return map;
	}
}

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