java设计模式学习笔记-19-解释器模式

解释器模式

public abastract class Expression{
    //解释公式和数值，key为参数[a,b,c],value为具体的值
    //a=10,b=20...
    public abstract int interpreter(HashMap<String,Integer> var);
}
//变量的解释器
public class VarExpression extends Expression{
    private String key;
    public VarExpression(String key){
        this.key = key;
    }
    
    //根据变量名称返回对应值
    public int interpreter(HashMap<String,Integer> var){
        return var.get(this.key);
    }
    
}
//抽象运算符解释器
public class SymbolExpression extends Expression{
    protected Expression left;
    protected Expression right;
    
    public SymbolExpression(Expression left,Expression right){
        this.left = left;
        this.right = right;
    }
    
    //本身无值
    public int interpreter(HashMap<String,Integer> var){
        return 0;
    }
}

//加法解析器
public class AddExpression extends SymbolExpression{
    public addExpression(Expression left,Expression right){
        super(left,right);
    }
    
    public int interpreter(HashMap<String,Integer> var){
        return super.left.interpreter(var) + super.right.interpreter(var);
    }
}

//减法
public class SubExpression extends SymbolExpression{
    public SubExpression(Expression left,Expression right){
        super(left,right);
    }
    
    public int interpreter(HashMap<String,Integer> var){
        return super.left.interpreter(var) - super.right.interpreter(var);
    }
}

public class Calculator{
    private Expression expression;
    
    public Calculator(String expStr){
        //安排运算顺序
        Stack<Expression> stack = new Stack<>();
        //拆分成字符数组
        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])));
                    break;
            }
        }
        this.expression = stack.pop();
        
    }
    
    public int run(HashMap<String,Integer> var){
        return this.expression.interpreter(var);
    }
}