行为型-解释器模式

概述

解释器模式（Interpreter Pattern）给定一个语言，定义它的文法的一种表示，并定义一个解释器，这个解释器使用该表示来解释语言中的句子。

适用场景

• 可以将一个需要解释执行的语言中的句子表示为一个抽象语法树
• 一些重复出现的问题可以用一种简单的语言来进行表达
• 文法较为简单

角色组成

• AbstractExpression（抽象表达式）：声明一个抽象的解释操作
• TerminalExpression（终结符表达式）：实现与文法中的终结符相关联的解释操作
• NonterminalExpression（非终结符表达式）：为文法中的非终结符实现解释操作
• Context（环境类）：包含解释器之外的一些全局信息

代码实现

1. 抽象表达式

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

2. 终结符表达式

public class TerminalExpression implements Expression {
    private String data;
    
    public TerminalExpression(String data) {
        this.data = data;
    }
    
    @Override
    public boolean interpret(String context) {
        return context.contains(data);
    }
}

3. 非终结符表达式

// 或表达式
public class OrExpression implements Expression {
    private Expression expr1;
    private Expression expr2;
    
    public OrExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }
    
    @Override
    public boolean interpret(String context) {
        return expr1.interpret(context) || expr2.interpret(context);
    }
}

// 与表达式
public class AndExpression implements Expression {
    private Expression expr1;
    private Expression expr2;
    
    public AndExpression(Expression expr1, Expression expr2) {
        this.expr1 = expr1;
        this.expr2 = expr2;
    }
    
    @Override
    public boolean interpret(String context) {
        return expr1.interpret(context) && expr2.interpret(context);
    }
}

4. 客户端

public class Client {
    // 规则：张三 或 李四
    public static Expression getOrRule() {
        Expression zhang = new TerminalExpression("张三");
        Expression li = new TerminalExpression("李四");
        return new OrExpression(zhang, li);
    }
    
    // 规则：男性 且 已婚
    public static Expression getAndRule() {
        Expression male = new TerminalExpression("男");
        Expression married = new TerminalExpression("已婚");
        return new AndExpression(male, married);
    }
    
    public static void main(String[] args) {
        Expression orRule = getOrRule();
        Expression andRule = getAndRule();
        
        System.out.println("张三是否符合规则: " + orRule.interpret("张三"));
        System.out.println("王五是否符合规则: " + orRule.interpret("王五"));
        
        System.out.println("男 已婚 是否符合规则: " + andRule.interpret("男 已婚"));
        System.out.println("女 已婚 是否符合规则: " + andRule.interpret("女 已婚"));
    }
}

# 输出
张三是否符合规则: true
王五是否符合规则: false
男 已婚 是否符合规则: true
女 已婚 是否符合规则: false

类图

实际案例：计算器

// 数字表达式
public class NumberExpression implements Expression {
    private int number;
    
    public NumberExpression(int number) {
        this.number = number;
    }
    
    public int interpret() {
        return number;
    }
}

// 加法表达式
public class AddExpression implements Expression {
    private Expression left;
    private Expression right;
    
    public AddExpression(Expression left, Expression right) {
        this.left = left;
        this.right = right;
    }
    
    public int interpret() {
        return left.interpret() + right.interpret();
    }
}

// 使用
Expression result = new AddExpression(
    new NumberExpression(10),
    new NumberExpression(20)
);
System.out.println(result.interpret());  // 30

JDK 中的应用

• java.util.Pattern
• java.text.Format
• Spring EL 表达式

优缺点

优点：

• 可扩展性好
• 增加新的解释表达式较为方便
• 易于实现简单文法

缺点：

• 可利用场景比较少
• 对于复杂的文法比较难维护
• 解释器模式会引起类膨胀