行为型模式-解释器模式

Posted 2023-03-10 风流 少年

定义

案例

加减法计算器。

/**
 * 抽象表达式类
 */
public abstract class AbstractExpression 
    // 解释器
    public abstract int interpret(Context context);

/**
 * 封装变量的类(变量也是一种表达式)
 */
public class Variable extends AbstractExpression 
    // 变量名
    private String name;

    public Variable(String name) 
        this.name = name;
    

    @Override
    public int interpret(Context context) 
        // 当表达式是变量的时候此时解释器是用来获取变量的值
        // 如果整个表达式的值的最后一个表达式是一个值，整个解释器就结束
        return context.getValue(this);
    

    @Override
    public String toString() 
        return name;
    

/**
 * 加法表达式
 */
public class Minus extends AbstractExpression 

    // -号左边的表达式
    private AbstractExpression left;
    // -号右边的表达式（right可能还是一个加减操作）
    private AbstractExpression right;

    public Minus(AbstractExpression left, AbstractExpression right) 
        this.left = left;
        this.right = right;
    

    @Override
    public int interpret(Context context) 
        return left.interpret(context) - right.interpret(context);
    

    @Override
    public String toString() 
        return "(" + left.toString() + " - " + right.toString() + ")";
    

/**
 * 加法表达式
 */
public class Plus extends AbstractExpression 

    // +号左边的表达式
    private AbstractExpression left;
    // +号右边的表达式
    private AbstractExpression right;

    public Plus(AbstractExpression left, AbstractExpression right) 
        this.left = left;
        this.right = right;
    

    @Override
    public int interpret(Context context) 
        return left.interpret(context) + right.interpret(context);
    

    @Override
    public String toString() 
        return "(" + left.toString() + " + " + right.toString() + ")";
    

/**
 * 环境角色类：整个表达式中的所有值都存储在这里
 */
public class Context 
    // 用来存储变量和对应的值
    private Map<Variable, Integer> map = new HashMap<>();

    // 添加变量的功能
    public void assign(Variable var, Integer value) 
        map.put(var, value);
    

    // 根据变量获取对应的值
    public int getValue(Variable var) 
        return map.get(var);
    

public class Client 
    public static void main(String[] args) 
        // 创建环境对象
        Context context = new Context();

        // 创建多个变量对象
        Variable a = new Variable("a");
        Variable b = new Variable("b");
        Variable c = new Variable("c");
        Variable d = new Variable("d");
        context.assign(a, 1);
        context.assign(b, 2);
        context.assign(c, 3);
        context.assign(d, 4);
		
		// 一层嵌套一层，类似于递归
        AbstractExpression expression = new Minus(a, new Plus(new Minus(b, c), d));
        int result = expression.interpret(context);
        // (a - ((b - c) + d))=-2
        System.out.println(expression + "=" + result);