转载自：https://mp.weixin.qq.com/s/f9N62Uj8Uf-dsybKcGGg6Q
解释，一定是针对某种语言的拆解、释意，并按照文法翻译、转换成另一种表达形式以达到目标能够理解的目的。比如我们都知道Java编程语言是人类可以理解的语言，程序写好后要先进行编译生成字节码（class文件），然后对此文件解释成机器码，最终机器才可以理解并执行，这就是解释器存在的意义。 
就拿我们人类的自然语言来举例，比如我们要进行英文翻译工作，首先要对一句话（表达式）进行拆解，而拆开后的单词就成了不可再分的终极表达式，例如说对英语句子“I love you”（非终极表达式）进行拆解，按空格分割为单词“I”、“love”、“you”（终极表达式），然后翻译每个单词再合并成“我爱你”，貌似很简单的样子。再看句子“I love that you love”，翻译成“我爱你那个你爱”。 
这简直太荒谬了，这句明明是“我爱你所爱”的意思，貌似这里的拆解方式是有讲究的。“that you love”在这里应该是作为从句出现，所以它应该属于一个特殊的“非终极表达式”，有自己独特的翻译方式，而不是简单的单词拼接了。我们意识到语言的翻译绝非易事，但至少我们通过思考搞明白了终极与非终极表达式的区别、表达式的多态性、以及表达式的自包含关系结构。 化繁为简，为了保持例子的简约实用风格，我们决定自己发明一种语言，什么语言呢？对于骨灰级网游玩家来说打怪升级是最漫长的过程，既浪费时间又伤害身体，该怎么解决这个问题呢？有网瘾，电电就好。 
开个玩笑，所以呢我们研发了一款挂机程序并起名”耗子精“，它可以直接发送指令给鼠标驱动来实现点击、移动操作，从此解放我们的双手让游戏人物自动打怪升级。既然不操作鼠标，那就需要一段脚本告诉“耗子精”怎样去操作鼠标指针，于是我们发明了一种脚本语言“精神食粮”，像是下面这样：
BEGIN // 脚本开始
MOVE 500,600; // 鼠标移动到坐标(500, 600)
BEGIN LOOP 5 // 开始循环5次
LEFT_CLICK; // 循环体内单击左键
DELAY 1; // 每次延时1秒
END; // 循环体结束
RIGHT_DOWN; // 按下右键
DELAY 7200; // 延时2小时
END; // 脚本结束
看注释很容易就能理解这是要干什么了，玩家先让鼠标挪动到地图的某个点上，然后不停地点击了n次（比如此处简化为5次）过后人物便到达了刷怪地点了（计算好延时时间），最后按下右键触发技能并一直不松开，直到挂机2小时后结束，这样便实现了自动打怪升级。
我们现在来对这个语言的表达式进行拆解、抽象、建模，可以看到除了循环（非终极表达式）以外其他的都是单个命令不可以拆了，也就是我们之前讲过的终极表达式，按照这个脚本我们先看一张结构图。 
可以看到从始发节点“指令序列表达式”（根）开始被拆解成三个分支，第一步和第三步都是执行鼠标动作的终极表达式了（叶），而第二步的“循环”则属于非终极表达式（枝），它的循环体内可以包含多步指令，所以它包括一个子指令集（枝），然后继续往下延续出“左键单击表达式”（枝）和“系统延时表达式”（叶），最后“单击”其实就是“按下”与“松开”的组合了。有没有这个语义树结构好像似曾相识？没错，这就是之前讲过的“组合模式”，我们正是利用了“组合模式”（强调结构型）的结构模型构建了这个语义树（Syntax Tree），来完成我们的翻译工作（这里强调行为型）。
开始写代码，这么多表达式到底应该从哪里开始定义呢？不管三七二十一它们统统都是表达式，先写个表达式总抽象。
public interface Expression { // 表达式接口
public void interpret(); // 解释方法
}
可以看到这个接口定义了表达式的通用解释方法标准，一切表达式都得符合这个规则。接下来我们先从最基本的原子操作（终极表达式）开始定义实现类，它们应该依次是移动鼠标、左（右）键按下（松开）、系统延时表达式等，雷同的我们不做赘述，读者可以自己实现。
public class Move implements Expression {
// 鼠标位置坐标
private int x, y;
public Move(int x, int y) {
this.x = x;
this.y = y;
}
public void interpret() {
System.out.println("移动鼠标：【" + x + "," + y + "】");
}
}
public class LeftDown implements Expression {
public void interpret() {
System.out.println("按下鼠标：左键");
}
}
public class LeftUp implements Expression {
public void interpret() {
System.out.println("松开鼠标：左键");
}
}
public class Delay implements Expression {
private int seconds;// 延时秒数
public Delay(int seconds) {
this.seconds = seconds;
}
public int getSeconds() {
return seconds;
}
public void interpret() {
System.out.println("系统延迟：" + seconds + "秒钟");
try {
Thread.sleep(seconds * 1000);
} catch (InterruptedException e) {
e.printStackTrace();
}
}
}
很简单，它们都实现了interpret方法，并进行了相关操作的模拟。照猫画虎，下来实现非终极表达式：左（右）键单击表达式、循环表达式、以及指令集序列表达式等。
public class LeftClick implements Expression {
private Expression leftDown;
private Expression leftUp;
public LeftClick() {
this.leftDown = new LeftDown();
this.leftUp = new LeftUp();
}
public void interpret() {
//单击=先按下再松开
leftDown.interpret();
leftUp.interpret();
}
}
这里有点意思了，单击表达式被我们继续拆分成“按下”及“松开”两个原子操作，由于点击是个固定的死操作，并不需要提供给客户端任何灵活性把它们传入进来，所以我们在构造时（第7行）主动实例化了它们。接下来是循环表达式，我们需要知道循环次数，以及循环体内要执行的表达式。
public class Repetition implements Expression {
private int loopCount;// 循环次数
private Expression expression;// 循环体表达式
public Repetition(Expression expression, int loopCount) {
this.expression = expression;
this.loopCount = loopCount;
}
public void interpret() {
while (loopCount > 0) {
expression.interpret();
loopCount--;
}
}
}
清晰明了，循环表达式被初始化后用这些参数进行循环、并调用循环体表达式的解释方法，继续向下传递，至于这个表达式里具体还有什么子表达式我们根本不关心，这里主要负责循环调用，仅此而已。最后就是指令集序列表达式的实现了。
public class Sequence implements Expression {
// 指令集序列
private List expressions;
public Sequence(List expressions) {
this.expressions = expressions;
}
public void interpret() {
// 循环挨个解析每条指令
expressions.forEach(exp -> exp.interpret());
}
}
我们要运行的脚本一定是有先后顺序的，所以这个指令集表达式里包含一个List，在构造时（第5行）由客户端传入，并于第11行挨个顺序调用解释方法。貌似脚本用到的表达式已经定义完毕，客户端开始调用。
public class Client {
public static void main(String[] args) {
/*
* BEGIN // 脚本开始
* MOVE 500,600; // 鼠标移动到坐标(500, 600)
* BEGIN LOOP 5 // 开始循环5次
* LEFT_CLICK; // 循环体内单击左键
* DELAY 1; // 每次延时1秒
* END; // 循环体结束
* RIGHT_DOWN; // 按下右键
* DELAY 7200; // 延时2小时
* END; // 脚本结束
*/
// 构造指令集语义树，实际情况会交给语法解析器（Evaluator or Parser）。
Expression sequence = new Sequence(Arrays.asList(
new Move(500, 600),
new Repetition(
new Sequence(
Arrays.asList(new LeftClick(),
new Delay(1))
),
5
),
new RightDown(),
new Delay(7200)
));
sequence.interpret();
/*打印输出
移动鼠标：【500,600】
按下鼠标：左键
松开鼠标：左键
系统延迟：1秒钟
按下鼠标：左键
松开鼠标：左键
系统延迟：1秒钟
按下鼠标：左键
松开鼠标：左键
系统延迟：1秒钟
按下鼠标：左键
松开鼠标：左键
系统延迟：1秒钟
按下鼠标：左键
松开鼠标：左键
系统延迟：1秒钟
按下鼠标：右键
系统延迟：7200秒钟
*/
}
}
注意看第16行，仔细参照注释中的脚本并实例化我们的语义树结构，最后只需调用根节点的interpret()方法即可完成整个解释工作。其实对于这个脚本转语义树的工作我们完全可以自己实现一个Evaluator来分析这段脚本并生成语义树（类似于编译的过程），由于这并不属于解释器模式的范畴，所以我们就不混淆进来了，这里我们留给读者朋友自己实现。
终于，“耗子精”有了脚本识别的能力，并顺利对接鼠标驱动，帮我们自动完成升级，玩家再也不用没日没夜地做那些无聊至极的重复动作了，并且后期如果需要更多的功能还可以对表达式继续进行扩展（比如对键盘指令的解释），我们只需优雅地植入语义树即可，就这么简单。正是因为我们对语言的语法解析、表达式抽象化，关系结构化，使得让翻译工作变得即插即用，解释器模式不但提高了代码的易读性、易用性、可维护性，更重要的是对未来语言变化的可扩展性。
