解释器模式

解释器模式UML类图

解释器模式java实现

/**
 * Expression.
 */
public abstract class Expression {

  public abstract int interpret();

  @Override
  public abstract String toString();
}

/**
 * PlusExpression.
 */
public class PlusExpression extends Expression {

  private Expression leftExpression;
  private Expression rightExpression;

  public PlusExpression(Expression leftExpression, Expression rightExpression) {
    this.leftExpression = leftExpression;
    this.rightExpression = rightExpression;
  }

  @Override
  public int interpret() {
    return leftExpression.interpret() + rightExpression.interpret();
  }

  @Override
  public String toString() {
    return "+";
  }
}

/**
 * MinusExpression.
 */
public class MinusExpression extends Expression {

  private Expression leftExpression;
  private Expression rightExpression;

  public MinusExpression(Expression leftExpression, Expression rightExpression) {
    this.leftExpression = leftExpression;
    this.rightExpression = rightExpression;
  }

  @Override
  public int interpret() {
    return leftExpression.interpret() - rightExpression.interpret();
  }

  @Override
  public String toString() {
    return "-";
  }

}

/**
 * MultiplyExpression.
 */
public class MultiplyExpression extends Expression {

  private Expression leftExpression;
  private Expression rightExpression;

  public MultiplyExpression(Expression leftExpression, Expression rightExpression) {
    this.leftExpression = leftExpression;
    this.rightExpression = rightExpression;
  }

  @Override
  public int interpret() {
    return leftExpression.interpret() * rightExpression.interpret();
  }

  @Override
  public String toString() {
    return "*";
  }

}

/**
 * NumberExpression.
 */
public class NumberExpression extends Expression {

  private int number;

  public NumberExpression(int number) {
    this.number = number;
  }

  public NumberExpression(String s) {
    this.number = Integer.parseInt(s);
  }

  @Override
  public int interpret() {
    return number;
  }

  @Override
  public String toString() {
    return "number";
  }
}

/**
 * The Interpreter pattern is a design pattern that specifies how to evaluate sentences in a
 * language. The basic idea is to have a class for each symbol (terminal or nonterminal) in a
 * specialized computer language. The syntax tree of a sentence in the language is an instance of
 * the composite pattern and is used to evaluate (interpret) the sentence for a client.
 *
 * <p>In this example we use the Interpreter pattern to break sentences into expressions ({@link
 * Expression}) that can be evaluated and as a whole form the result.
 口译员模式是一种设计模式，用于指定如何评估语言中的句子。 基本思想是为使用专用计算机语言的每个符号（终端或非终端）提供一个类。 该语言中句子的语法树是复合模式的一个实例，用于为客户评估（解释）该句子。
<p>在此示例中，我们使用“解释器”模式将句子分解为可求值的表达式（{@link Expression}），并从整体上形成结果。
 */
public class App {

  private static final Logger LOGGER = LoggerFactory.getLogger(App.class);

  /**
   * Program entry point.
   *
   * <p>Expressions can be evaluated using prefix, infix or postfix notations This sample uses
   * postfix, where operator comes after the operands.
   *
   * @param args command line args
   */
  public static void main(String[] args) {
    var tokenString = "4 3 2 - 1 + *";
    var stack = new Stack<Expression>();

    var tokenList = tokenString.split(" ");
    for (var s : tokenList) {
      if (isOperator(s)) {
        var rightExpression = stack.pop();
        var leftExpression = stack.pop();
        LOGGER.info("popped from stack left: {} right: {}",
            leftExpression.interpret(), rightExpression.interpret());
        var operator = getOperatorInstance(s, leftExpression, rightExpression);
        LOGGER.info("operator: {}", operator);
        var result = operator.interpret();
        var resultExpression = new NumberExpression(result);
        stack.push(resultExpression);
        LOGGER.info("push result to stack: {}", resultExpression.interpret());
      } else {
        var i = new NumberExpression(s);
        stack.push(i);
        LOGGER.info("push to stack: {}", i.interpret());
      }
    }
    LOGGER.info("result: {}", stack.pop().interpret());
  }

  public static boolean isOperator(String s) {
    return s.equals("+") || s.equals("-") || s.equals("*");
  }

  /**
   * Get expression for string.
   */
  public static Expression getOperatorInstance(String s, Expression left, Expression right) {
    switch (s) {
      case "+":
        return new PlusExpression(left, right);
      case "-":
        return new MinusExpression(left, right);
      case "*":
        return new MultiplyExpression(left, right);
      default:
        return new MultiplyExpression(left, right);
    }
  }
}