你发年终奖了吗？

年终奖是很多人的快乐，也是很多人的痛。

当然快乐与你有没有缘，就要看快乐与你有没有缘了，这是个玄学。

在一些公司是如果一个人有年终奖其他人就会都有，在一些公司是根据你整年的表现来的。

比如有这么一家公司：

他们发年终奖规则是这样的：勤劳的人、积极的人 并且 名字是小明、小亮、小路的才会发。

比如：勤劳的小亮、积极的小明这类的就会发年终奖。

其他比如：偷懒的小明、勤劳的小丽 这种的是不给发的。

用表达式表示是否发年终奖是这样的：

（勤劳的人 || 积极的人）&& （小明 || 小亮 || 小路）

那我们今天用这个例子给大家讲一个设计模式——解释器模式

解释器模式（Interpreter Pattern）提供了评估语言的语法，这种模式实现了一个表达式接口，该接口解释一个特定的上下文。

这种设计模式多用在SQL解析、符号处理引擎等。

它长这样：

我是这样理解的:

其他他就是把我们的if else 按照某种规则进行分类处理，把条件传入解析引擎，然后返回计算结果。

Iexpression

package interpreter;


public interface Iexpression {
    public boolean interpret(String data);
}

Terminalexpression

package interpreter;

import java.util.Arrays;
import java.util.List;


public class Terminalexpression implements  Iexpression{

    // 定义条件
    List conditions;
    public Terminalexpression(String ... args){
        conditions =  Arrays.asList(args);
    }
    // 判断是否是勤奋、积极、小明、小亮等等
    @Override
    public boolean interpret(String data) {
        if (data == null) {
            return false;
        }
        return conditions.contains(data);
    }
}

NoTerminalexpression

package interpreter;


public class NoTerminalexpression implements Iexpression {
    Iexpression expression01;
    Iexpression expression02;
    // 非终结表达式 需要调用终结表达式
    public NoTerminalexpression(Iexpression expression1, Iexpression expression2){
        this.expression01 = expression1;
        this.expression02 = expression2;
    }
    @Override
    public boolean interpret(String data) {
        String[] arrs = data.split("的");
        if (arrs == null || arrs.length != 2) {
            return false;
        }
        // 判断是否同时符合2个条件
        return expression01.interpret(arrs[0]) && expression02.interpret(arrs[1]);
    }
}

Context

​```package interpreter;


public class Context {
    private String[] types = { "勤奋", "积极"};
    private String[] names = { "小明", "小亮", "小路"};
    // 最牛的表达式
    Iexpression expression;
    public Context() {
        Iexpression typeexpression = new Terminalexpression(types);
        Iexpression nameexpression = new Terminalexpression(names);
        expression = new NoTerminalexpression(typeexpression, nameexpression);
    }

    //调用相关表达式类的解释方法
    public void freeRide(String info) {
        boolean ok = expression.interpret(info);
        if(ok){
            System.out.println("给"+info+"发年终奖！");
        } else {
            System.out.println("不给"+info+"发年终奖！");
        }
    }
}

Client

package interpreter;


public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.freeRide("勤奋的小亮");
        context.freeRide("积极的小明");
        context.freeRide("懒惰的小莉");
        context.freeRide("偷懒的小明");
    }
}

输出结果：

这几个类的关系：

解释器模式好像平时很少见过，见得少也可以学习学习。

有钱人见得少，你不还想着成为有钱人的嘛 ， 哈哈！

假期剩下2天了，珍惜吧！