解释器模式 Interpreter 行为型 设计模式（十九）

public static int add(int a,int b){
return a+b;
}

public static int add(int a,int b,int c){
return a+b-c;
}

package interpret;

public class Client {

public static void main(String[] args) {

AbstractExpression expression = new Minus(
new Plus(new Plus(new Plus(new Value(1), new Value(2)), new Value(3)), new Value(4)),
new Value(5));
System.out.println(expression.interpret());
}
}

int f(int x) {
if (1 == x) {
return x;
} else {
return x+f(x-1);
}
}

package interpret;
public class Client {
public static void main(String[] args) {
        //定义变量X和Y,初始值都为0
        Variable variableX = new Variable("x", 0);
        Variable variableY = new Variable("y", 0);
        //计算公式为: X+Y+X-1
        AbstractExpression expression2 = new Minus(new Plus(new Plus(variableX, variableY), variableX),
        new Value(1));
        variableX.setValue(1);
        variableY.setValue(3);
        System.out.println(expression2.interpret());
        variableX.setValue(5);
        variableY.setValue(6);
        System.out.println(expression2.interpret());
    }
}

package interpret.refactor;

public abstract class AbstractExpression {
public abstract int interpret(Context ctx);
}

package interpret.refactor;

public class Value extends AbstractExpression {

private int value;

Value(int value) {
this.value = value;
}

@Override
public int interpret(Context ctx) {
return value;
}

@Override
public String toString() {
return new Integer(value).toString();
}
}

package interpret.refactor;

import java.util.HashMap;

import java.util.Map;

public class Context {

private Map<Variable, Integer> map = new HashMap<Variable, Integer>();

public void assign(Variable var, Integer value) {
map.put(var, new Integer(value));
}

public int getValue(Variable var) {
Integer value = map.get(var);
return value;
}
}

package interpret.refactor;


public class Client {

public static void main(String[] args) {

Context ctx = new Context();

Variable a = new Variable("a");
Variable b = new Variable("b");
Variable c = new Variable("c");
Variable d = new Variable("d");
Variable e = new Variable("e");
Value v = new Value(1);

ctx.assign(a, 1);
ctx.assign(b, 2);
ctx.assign(c, 3);
ctx.assign(d, 4);
ctx.assign(e, 5);

AbstractExpression expression = new Minus(new Plus(new Plus(new Plus(a, b), c), d), e);

System.out.println(expression + "= " + expression.interpret(ctx));
}
}

/**
   * 解析字符串,构造抽象语法树 方法只是为了理解：解释器模式 方法默认输入为合法的字符串，没有考虑算法优化、效率或者不合法字符串的异常情况
   *
   * @param sInput 合法的加减法字符串 比如 1+2+3
   */
  public static AbstractExpression getAST(String sInput) {
    //接收字符串参数形如 "1+2-3"
    //将字符串解析到List valueAndSymbolList中存放
    List<String> valueAndSymbolList = new ArrayList<>();
    //先按照 加法符号 + 拆分为数组,以每个元素为单位使用 +连接起来存入List
    //如果以+ 分割内部还有减法符号 - 内部以减法符号- 分割
    //最终的元素的形式为 1,+,2,-,3
    String[] splitByPlus = sInput.split("\\+");
    for (int i = 0; i < splitByPlus.length; i++) {
      if (splitByPlus[i].indexOf("-") < 0) {
        valueAndSymbolList.add(splitByPlus[i]);
      } else {
        String[] splitByMinus = splitByPlus[i].split("\\-");
        for (int j = 0; j < splitByMinus.length; j++) {
          valueAndSymbolList.add(splitByMinus[j]);
          if (j != splitByMinus.length - 1) {
            valueAndSymbolList.add("-");
          }
        }
      }
      if (i != splitByPlus.length - 1) {
        valueAndSymbolList.add("+");
      }
    }
    //经过前面处理元素的形式为 1,+,2,-,3
    //转换为抽象语法树的形式
    AbstractExpression leftExpression = null;
    AbstractExpression rightExpression = null;
    int k = 0;
    while (k < valueAndSymbolList.size()) {
      if (!valueAndSymbolList.get(k).equals("+") && !valueAndSymbolList.get(k).equals("-")) {
        rightExpression = new Value(Integer.parseInt(valueAndSymbolList.get(k)));
        if (leftExpression == null) {
          leftExpression = rightExpression;
        }
      }
      k++;
      if (k < valueAndSymbolList.size()) {
        rightExpression = new Value(Integer.parseInt(valueAndSymbolList.get(k + 1)));
        if (valueAndSymbolList.get(k).equals("+")) {
          leftExpression = new Plus(leftExpression, rightExpression);
        } else if (valueAndSymbolList.get(k).equals("-")) {
          leftExpression = new Minus(leftExpression, rightExpression);
        }
        k++;
      }
    }
    return leftExpression;
  }