通俗易懂的Java设计模式之 --解释器模式

Java中的解释器模式（Interpreter Pattern）是一种行为型设计模式，它定义了一种语言文法，以及解释该语言的解释器，用于解释一些特定的表达式或语句。

解释器模式中包含两个核心角色：抽象表达式（AbstractExpression）和具体表达式（ConcreteExpression）。抽象表达式定义了一个解释器接口，而具体表达式则负责实现具体的解释逻辑。

下面是一个简单的例子，假设我们需要实现一个简单的加减乘除计算器，它支持以下操作：

• 数字：可以输入任意数字，例如 123

• 加法：使用符号 +，例如 1+2

• 减法：使用符号 -，例如 3-1

• 乘法：使用符号 ，例如 23

• 除法：使用符号 /，例如 6/2

现在我们可以使用解释器模式来实现该计算器，首先定义一个抽象表达式：

public interface Expression {
    int interpret();
}

然后实现具体的表达式：

//数字解释器
public class NumberExpression implements Expression {
    private final int number;

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

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

//加法解释器
public class AddExpression implements Expression {
    private final Expression leftExpression;
    private final Expression rightExpression;

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

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

//减法解释器
public class SubtractExpression implements Expression {
    private final Expression leftExpression;
    private final Expression rightExpression;

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

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

//乘法解释器
public class MultiplyExpression implements Expression {
    private final Expression leftExpression;
    private final Expression rightExpression;

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

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

//除法解释器
public class DivideExpression implements Expression {
    private final Expression leftExpression;
    private final Expression rightExpression;

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

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

最后定义一个计算器解释器：

public class Calculator {
    private final Map<String, Expression> variables = new HashMap<>();

    public int calculate(String expression) {
        Stack<Expression> stack = new Stack<>();

        for (String token : expression.split("\\s")) {
            if (isOperator(token)) {
                Expression rightExpression = stack.pop();
                Expression leftExpression = stack.pop();

                switch (token) {
                    case "+":
                stack.push(new AddExpression(leftExpression, rightExpression));break;
                    case "-":
                stack.push(new SubtractExpression(leftExpression, rightExpression));break;
                    case "*":
                stack.push(new MultiplyExpression(leftExpression, rightExpression));break;
                   case "/":
                stack.push(new DivideExpression(leftExpression, rightExpression));break; }
} else {
               Expression expressionObj = new NumberExpression(Integer.parseInt(token));
               stack.push(expressionObj);
                  }
               }
           return stack.pop().interpret();
          }
         private boolean isOperator(String token) {
                 return "+".equals(token) || "-".equals(token) || "*".equals(token) || "/".equals(token);
          }
}

现在，我们就能使用这个计算器进行加减乘除运算了。

Calculator calculator = new Calculator();
int result = calculator.calculate("3 4 5 * -");
System.out.println(result); // -17

在上面的例子中，我们首先定义了一个抽象表达式接口 Expression，然后实现了具体的表达式类 NumberExpression、AddExpression、SubtractExpression、MultiplyExpression 和 DivideExpression，这些类实现了 Expression 接口中定义的 interpret() 方法，用于解释对应的表达式。

我们还定义了一个 Calculator 类，用于将输入的表达式解析成一个表达式树，然后通过遍历表达式树，使用表达式类计算表达式的值。通过这种方式，我们就实现了一个简单的加减乘除计算器。