解释器模式

什么是解释器模式？？

举个例子

假设现在有一个业务需求如下：

输入一个模式公式（加减运算），然后输入模型中的参数，运算出结果。

设计要求：

1、公式可以运行时编辑，并且符合正常的算术书写方式。

2、高扩展性

抽象表达式类

package sehjimoshi.interpreter;

import java.util.HashMap;

/**
 * <p>Description:</p>
 * 
 * @author Administrator
 * @date 2019年1月8日下午1:26:09
 * @version 1.0
 */
public abstract class Expression {
    // 解释公式和数值，其中的var中的key值是公式中的参数，value是具体的数值
    public abstract int interpreter(HashMap<String,Integer> var);
}

变量解释器类

package sehjimoshi.interpreter;

import java.util.HashMap;

/**
 * <p>Description:</p>
 * 
 * @author Administrator
 * @date 2019年1月8日下午1:28:13
 * @version 1.0
 */
public class VarExpression extends Expression {
    private String key;

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


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

抽象运算符号解释器类

/**
 * 
 */
package sehjimoshi.interpreter;

/**
 * <p>Description:</p>
 * 
 * @author Administrator
 * @date 2019年1月8日下午1:30:00
 * @version 1.0
 */
public abstract class SymbolExpression extends Expression {
    protected Expression left;
    protected Expression right;
    
    public SymbolExpression(Expression left, Expression right) {
        super();
        this.left = left;
        this.right = right;
    }
    
    
}

加法解释器类

/**
 * 
 */
package sehjimoshi.interpreter;

import java.util.HashMap;

/**
 * <p>Description:</p>
 * 
 * @author Administrator
 * @date 2019年1月8日下午1:31:27
 * @version 1.0
 */
public class AddExpression extends SymbolExpression {
    
    
    public AddExpression(Expression left, Expression right) {
        super(left, right);

    }

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

}

减法解释器类

/**
 * 
 */
package sehjimoshi.interpreter;

import java.util.HashMap;

/**
 * <p>Description:</p>
 * 
 * @author Administrator
 * @date 2019年1月8日下午1:32:57
 * @version 1.0
 */
public class SubExpression extends SymbolExpression {

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

    }


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

}

解释器封装类

/**
 * 
 */
package sehjimoshi.interpreter;

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

/**
 * <p>Description:</p>
 * 
 * @author Administrator
 * @date 2019年1月8日下午1:34:05
 * @version 1.0
 */
public class Calculator {
    // 定义表达式
    private Expression expression;
    
    public Calculator(String expStr) {
        // 定义一个栈
        Stack<Expression> stack = new Stack<Expression>();
        // 表达式拆分为数组
        char[] charArray = expStr.toCharArray();
        
        // 运算
        Expression left = null;
        Expression right = null;
        
        for (int i = 0; i < charArray.length; i++) {
            switch (charArray[i]) {
            case '+':
                left = stack.pop();
                right = new VarExpression(String.valueOf(charArray[++i]));
                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:
                stack.push(new VarExpression(String.valueOf(charArray[i])));
                
            }
        }
        
        // 把运算结果抛出来
        this.expression = stack.pop();
    }
    
    /**
     * 开始运算
     */
    public int run(HashMap<String,Integer> var) {
        return this.expression.interpreter(var);
    }
}

客户端模拟类

/**
 * 
 */
package sehjimoshi.interpreter;

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

/**
 * <p>Description:</p>
 * 
 * @author Administrator
 * @date 2019年1月8日下午1:42:20
 * @version 1.0
 */
public class Client {

    /**
     * @param args
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        // TODO Auto-generated method stub
        String expStr = getExpStr();
        
        HashMap<String, Integer> var = getValue(expStr);
        
        Calculator cal = new Calculator(expStr);
        System.out.println("运算结果:"+expStr+"="+cal.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 exprStr) throws IOException {
        HashMap<String,Integer> map = new HashMap<String,Integer>();
        
        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;
    }

}

运行结果：