JavaDog程序狗
发布于 2026-11-16 / 5 阅读
0
0

【设计模式】跟着狗哥复习设计模式(十五):解释器模式

晚上进门,手里还拎着菜。对着家里的小设备说一句“开灯”,灯亮了,确实挺方便。

可机器为什么能听懂“开灯”?因为我们提前告诉了它:遇到这两个字,就执行开灯动作。

加瓦狗输入开灯口令并由规则解释

解释器模式干的就是这类事:给一套简单语句定规则,再按规则读懂它。

口令全塞进判断里,能用但会变长

刚开始只有“开灯”和“关灯”,两个 if 就写完了。

口令不断增加导致判断越来越长

后来又来“开空调”“拉窗帘”“播放音乐”,判断会越堆越多。想找某条规则,得在一长串代码里翻。

这时候可以把每条规则单独拆开。谁认识这句口令,谁负责解释。

先定两条很小的规则

咱不碰复杂语法,只定两条:

智能家居口令与表达式规则表

“开灯”代表打开电灯,“关灯”代表关闭电灯。

这已经算一套很小的语言了。词不多,意思固定,机器照着规则就能读。

先看关键 UML 图

解释器模式关键 UML 类图

图里主要有三个角色:

  • Expression:所有规则都要遵守的解释接口。
  • LightOnExpression:只认识“开灯”。
  • LightOffExpression:只认识“关灯”。
  • SmartHomeInterpreter:拿着所有规则,挨个问谁能解释。

每个类只管一小块,代码看起来就没那么挤了。

表达式接口只做一件事

public interface Expression {
    boolean interpret(String command);
}

传进一条口令,能解释就返回 true,听不懂就返回 false。

接口就这么点儿。名字有点学术,实际干的活很朴素。

“开灯”表达式怎么写

public class LightOnExpression implements Expression {
    private final Light light;

    public LightOnExpression(Light light) {
        this.light = light;
    }

    @Override
    public boolean interpret(String command) {
        if (!"开灯".equals(command)) {
            return false;
        }
        light.on();
        return true;
    }
}

它先看看口令是不是“开灯”。对得上,就让电灯执行 on();对不上,安安静静返回 false。

开灯口令被表达式解释并执行的流程

LightOffExpression 也差不多,只是识别“关灯”,然后调用 light.off()。

public boolean interpret(String command) {
    if (!"关灯".equals(command)) {
        return false;
    }
    light.off();
    return true;
}

总解释器把规则放到一起

public class SmartHomeInterpreter {
    private final List<Expression> expressions;

    public SmartHomeInterpreter(List<Expression> expressions) {
        this.expressions = expressions;
    }

    public void interpret(String command) {
        for (Expression expression : expressions) {
            if (expression.interpret(command)) {
                return;
            }
        }
        System.out.println("听不懂:" + command);
    }
}

它收到口令后,把规则挨个试一遍。找到能解释的,执行完就停。

这个例子看着和责任链有一点像。区别在于:责任链关心“谁来处理请求”,解释器关心“这段输入按哪条语法理解”。

规则里没有,就别硬猜

输入“跳舞”时,两条表达式都不认识。

未知口令无法被现有规则解释

程序会输出:

听不懂:跳舞

这反而是正常结果。解释器只能读懂提前定好的规则,不能凭空猜意思。要支持“跳舞”,就得补上对应规则。

把完整例子跑起来

public class InterpreterDemo {
    public static void main(String[] args) {
        Light light = new Light();
        SmartHomeInterpreter interpreter = new SmartHomeInterpreter(List.of(
                new LightOnExpression(light),
                new LightOffExpression(light)
        ));

        interpreter.interpret("开灯");
        interpreter.interpret("关灯");
        interpreter.interpret("跳舞");
    }
}

运行结果:

灯亮了
灯关了
听不懂:跳舞

从输入到结果,一共就三步:收到口令、匹配规则、执行动作。甭整得神神秘秘的。

新增一条规则,要改哪里

比如再支持“开风扇”,可以新增一个 FanOnExpression,然后放进表达式列表。

原来的开灯、关灯表达式都不用动。这是解释器模式比较顺手的地方:一条规则一个类,增加规则时少碰旧代码。

代价也很明显。规则一多,类的数量也会跟着涨。

哪些地方适合用

解释器模式适合与不适合的场景

比较常见的场景有:

  • 简单的搜索条件,比如 价格 > 100。
  • 固定格式的设备口令。
  • 权限表达式和小型规则配置。
  • 一些简单计算表达式。

要是语法已经复杂到有括号、优先级、变量和函数,自己堆解释器会很累。那种情况用成熟的解析工具更稳当,别硬扛。

还有一点,只有两三条固定判断,而且以后也不太会变,直接写 if-else 更清楚。模式不是越多越显本事。

狗哥收个尾

解释器模式可以这么记:先给简单语句定规则,再让表达式按规则解释。

这篇的“语言”只有开灯和关灯,所以代码很短。先把骨架看明白,以后碰到筛选条件、规则配置,就容易认出来了。

下一篇聊迭代器模式。咱拿排队取号来讲,一个一个往后走,应该比翻概念轻松。


评论