Java设计模式 _行为型模式_解释器模式

一、解释器模式

1、解释器模式
解释器模式（Interpreter Pattern）是一种行为型模式。它提供了评估语言的语法或表达式的方式。通过实现了一个表达式接口，通常该接口解释一个特定且重复出现的问题。

2、实现思路
（1）、定义表达式的规范接口
（2）、编写表达式的各种实现类，可以内置不同的参数，实现该接口。
（3）、封装工具类，包装简单表达式到表达式类的映射关系

二、代码示例

1、示例场景
重新定义++,–,,//四个表达式的作用，分别为第一个参数操作第二个参数两次。
如：a++b，应该返回a+b+b的值；ab，应该返回abb的值；

// 1、定义表达式规范
import java.math.BigDecimal;

public abstract class Expression {
    abstract double interpret();

    double getValue(double num) {
        return new BigDecimal(num).setScale(2, BigDecimal.ROUND_DOWN).doubleValue();
    }
}
// 2.1、编写基础规范，规定每一个操作元素的值为double类型两位小数
public class ValueExpression extends Expression {
    private double num;
    public ValueExpression(double num) {
        this.num = num;
    }
    @Override
    public double interpret() {
        return getValue(num);   // 表达式的操作元素为保留两位小数的double类型
    }
}
// 2.2、编写++表达式的实现类
public class AddAddExpression extends Expression {
    private Expression left;
    private Expression right;

    public AddAddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public double interpret() {
        return getValue(left.interpret() + right.interpret() + right.interpret());
    }
}
// 2.3、编写--表达式的实现类
public class SubSubExpression extends Expression {
    private Expression left;
    private Expression right;

    public SubSubExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public double interpret() {
        return getValue(left.interpret() - right.interpret() - right.interpret());
    }
}
// 2.4、编写**表达式的实现类
public class MulMulExpression extends Expression {
    private Expression left;
    private Expression right;

    public MulMulExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public double interpret() {
        return getValue(left.interpret() * right.interpret() * right.interpret());
    }
}

// 2.5、编写//表达式的实现类
public class DivDivExpression extends Expression {
    private Expression left;
    private Expression right;

    public DivDivExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }

    @Override
    public double interpret() {
        if (Double.compare(right.interpret(),0.0)==0){
            System.out.println("0不能做除数");
            return 0;
        }
        return getValue(left.interpret() / right.interpret() / right.interpret());
    }
}
// 3、封装符号和表达式的工具类
public class ExpressionTool {
    public static  double compute(double left,double right,String operation){
        Expression leftValue = new ValueExpression(left);
        Expression rightValue = new ValueExpression(right);
        double result = 0;
        switch (operation){
            case "++":
                result= new AddAddExpression(leftValue,rightValue).interpret();
                break;
            case "--":
                result= new SubSubExpression(leftValue,rightValue).interpret();
                break;
            case "**":
                result= new MulMulExpression(leftValue,rightValue).interpret();
                break;
            case "//":
                result= new DivDivExpression(leftValue,rightValue).interpret();
                break;
            default:
                result = 0;
        }
        return result;
    }
}
// 4、测试
public static void main(String[] args) {
        double result = ExpressionTool.compute(8, 2, "++");
        System.out.println("8+2+2="+result);
        result = ExpressionTool.compute(8, 2, "--");
        System.out.println("8-2-2="+result);
        result = ExpressionTool.compute(8, 2, "**");
        System.out.println("8*2*2="+result);
        result = ExpressionTool.compute(8, 2, "//");
        System.out.println("8/2/2="+result);

    }

运行结果

总结：
解释器模式一般用于定义某些新的表达式类型，如：新的运算表达式。也可以是兼容一些语法上的使用，如翻译一些脚本的功能（js，python，shell）等。比较常用的如mybatis-plus中(对象直接操作.eq,.like,.or等方法去解释成对应的sql语言去执行）。一般不同业务场景下用到的还是比较少，具体还是看业务是否需要定义新的表达式规范再来确定是否使用这种设计模式吧。

学海无涯苦作舟！！！