设计模式-行为型-解释器模式

简介

解释器模式是行为型模式的一种，在日常开发中极其少用，个人认为这是23种设计模式中最难理解的一种了，其是为程序编译而诞生的。下面以一个简单的加减法来示例。

Demo示例

1.首先定义一个解释器的上下文

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

public class Context {
    private Map<Expression, Integer> map = new HashMap<>();

    public void add(Expression expression, Integer value) {
        map.put(expression, value);
    }

    public Integer get(Expression expression) {
        return map.get(expression);
    }
}

2.首先定义一个Expression接口，然后AddExpression和SubExpression实现它。

public interface Expression {
    int interpret(Context context);
}

public class AddExpression implements Expression{

    private Expression expression1;
    private Expression expression2;

    public AddExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public int interpret(Context context) {
        return expression1.interpret(context) + expression2.interpret(context);
    }
}

public class SubExpression implements Expression{

    private Expression expression1;
    private Expression expression2;

    public SubExpression(Expression expression1, Expression expression2) {
        this.expression1 = expression1;
        this.expression2 = expression2;
    }

    @Override
    public int interpret(Context context) {
        return this.expression1.interpret(context) - this.expression2.interpret(context);
    }
}

3.解释器模式中通常会包含一个TerminalExpression，其也是实现了Expression。

public class TerminalExpression implements Expression{

    private String var;
    public TerminalExpression(String var) {
        this.var = var;
    }

    @Override
    public int interpret(Context context) {
        return context.get(this);
    }
}

4.客户端调用

public class Test {
    public static void main(String[] args) {
        Context context = new Context();
        TerminalExpression e1 = new TerminalExpression("e1");
        TerminalExpression e2 = new TerminalExpression("e2");
        TerminalExpression e3 = new TerminalExpression("e3");
        context.add(e1, 1);
        context.add(e2, 2);
        context.add(e3, 3);

        System.out.println(new AddExpression(e1, e2).interpret(context)); // 3
        System.out.println(new SubExpression(e3, e1).interpret(context)); // 2

    }
}