android 解释器模式

package com.chenxing.searchjob.sdk.view;

import android.util.Log;

import java.util.HashMap;
import java.util.Map;

public class TestClass {

    private String TAG=IMListView.class.getSimpleName();

    void msg(String msg){
        Log.i(TAG, "msg: "+msg);
    }

    public void main(){
        Calculator calculator = new Calculator();
        calculator.read("a = 1024");//读取表达式
        calculator.read("b = 512");
        msg("a = 1024");
        msg("b = 512");

        calculator.read("a + b");
        msg("a + b = " + calculator.calculate());//计算结果
        calculator.read("a - b");
        msg("a - b = " + calculator.calculate());

        msg("------------------------------------");

        calculator.read("jason = 10");
        calculator.read("jace = 18");
        calculator.read("jason + jace");
        msg("===>"+calculator.calculate());
    }

    public abstract class ArithmeticExpression {//抽象算术表达式

        public abstract Object interpret(Context context);//抽象解释方法
    }

    //数字表达式，用来解释数字
    public class NumExpression extends ArithmeticExpression {
        private String strNum;

        public NumExpression(String strNum) {
            this.strNum = strNum;
        }

        @Override
        public Integer interpret(Context context) {//解释数字
            return Integer.parseInt(strNum);
        }
    }

    //变量表达式，用来解释变量
    class VarExpression extends ArithmeticExpression {
        private String var;

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

        @Override
        public String interpret(Context context) {//解释变量
            return var;
        }
    }

    //加法表达式，用来解释加法,如a+b
    public class AddExpression extends ArithmeticExpression {
        private ArithmeticExpression left, right;//加号左右两边的内容

        public AddExpression(ArithmeticExpression left, ArithmeticExpression right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public Integer interpret(Context context) {//解释加法表达式的结果，即算出left+right的结果
            return  context.get((String) left.interpret(context)) + context.get((String) right.interpret(context));
        }
    }

    //减法表达式，用来解释减法,如a-b
    public class SubExpression extends ArithmeticExpression {
        private ArithmeticExpression left, right;//减号左右两边的内容

        public SubExpression(ArithmeticExpression left, ArithmeticExpression right) {
            this.left = left;
            this.right = right;
        }

        @Override
        public Integer interpret(Context context) {//解释减法表达式的结果，即算出left-right的结果
            return context.get((String) left.interpret(context)) - context.get((String) right.interpret(context));
        }
    }

    //等号表达式，用来解释变量赋值，如a=1024
    public class EqualExpression extends ArithmeticExpression {
        private ArithmeticExpression left, right;//等号左右两边的内容

        public EqualExpression(ArithmeticExpression left, ArithmeticExpression right) {
            this.left = left;
            this.right = right;
        }


        @Override
        public Object interpret(Context context) {//解释等号表达式的结果，并将结果保存到context，变量名为key,值为value
            context.put((String) left.interpret(context), (int) right.interpret(context));
            return null;
        }
    }

    public class Context {
        Map<String, Object> mMap = new HashMap<>();//使用HashMap来保存结果

        public void put(String key, int value) {
            mMap.put(key, value);
        }

        public int get(String key) {
            return (int) mMap.get(key);
        }
    }

    public class Calculator {//计算器类
        Context mContext = new Context();
        private ArithmeticExpression mExpression;

        public void read(String expression) {//读取表达式
            String[] split = expression.split(" ");//表达式以空格隔开，方便拆分
            switch (split[1]) {//根据不同符号去执行具体的解析操作
                case "=":
                    new EqualExpression(new VarExpression(split[0]), new NumExpression(split[2])).interpret(mContext);
                    break;
                case "+":
                    mExpression = new AddExpression(new VarExpression(split[0]), new VarExpression(split[2]));
                    break;
                case "-":
                    mExpression = new SubExpression(new VarExpression(split[0]), new VarExpression(split[2]));
                    break;
            }

        }

        public int calculate() {//计算结果
            return (int) mExpression.interpret(mContext);
        }
    }

}