【设计模式】用Java实现解释器模式_java解释器模式-CSDN博客

本文链接：https://blog.csdn.net/yuanmayuzhou/article/details/131470160

一.解释器模式介绍与使用场景

解释器模式（Interpreter Pattern）是一种行为设计模式，它用于解释一个特定的语言或表达式，并提供一种灵活的方式来进行解析和执行。该模式将语言的语法规则表示为一个解释器类的层次结构，并使用该结构来解析语言中的表达式。

在解释器模式中，通常包含以下角色：

抽象表达式（Abstract Expression）：定义一个抽象的解释操作，通常包含一个抽象方法interpret()，该方法根据具体的解释器实现来解释表达式。
终结符表达式（Terminal Expression）：实现抽象表达式接口，表示语言中的终结符（最小的语法单元），即无需再解释的基本元素。
非终结符表达式（Non-terminal Expression）：实现抽象表达式接口，表示语言中的非终结符，即由终结符和其他非终结符组合而成的复杂语法规则。
上下文（Context）：包含待解释的语言和相关的解释器实例。
客户端（Client）：创建和配置解释器对象，并通过解释器来解析表达式。

应用场景：

当有一个语言或表达式需要解释和执行，并且可以表示为一个抽象语法树时，可以使用解释器模式。例如，编译器、解析器、正则表达式引擎等都可以使用解释器模式。

当需要灵活地扩展和修改语言的语法规则时，解释器模式非常有用。通过添加新的解释器类或修改现有的解释器类，可以改变语言的行为和语法。

当某个问题可以被一组简单的规则表示，并且这些规则可以组合成复杂的规则时，可以使用解释器模式。解释器模式允许将复杂的规则拆分为简单的表达式，并通过组合这些表达式来构建复杂的规则。

当对于一些特定领域的问题，有一种自定义的语言或表达式可以简化问题的表达和求解时，解释器模式是一个有用的选择。通过定义一个专门的解释器来处理该领域的语言或表达式，可以提高问题的可读性和易用性。

需要注意的是，解释器模式可能会导致类的层次结构较深，并且每个表达式都需要对应一个解释器类，因此在设计时需要权衡复杂性和可维护性。另外，对于复杂的语法和表达式，解释器模式可能会带来性能上的开销，需要谨慎使用。

二.解释器模式实现

下面我们用java实现一下解释器模式。

首先，我们定义抽象表达式接口 Expression：

public interface Expression {
    int interpret(Context context);
}

然后，我们创建终结符表达式 NumberExpression：

public class NumberExpression implements Expression {
    private int number;
    
    public NumberExpression(int number) {
        this.number = number;
    }
    
    public int interpret(Context context) {
        return number;
    }
}

接下来，我们创建非终结符表达式 AddExpression：

public class AddExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;
    
    public AddExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }
    
    public int interpret(Context context) {
        int leftValue = leftExpression.interpret(context);
        int rightValue = rightExpression.interpret(context);
        return leftValue + rightValue;
    }
}

最后，我们定义上下文类 Context，它包含待解释的语言和相关的解释器实例

public class Context {
    private Map<String, Expression> variables;
    
    public Context() {
        variables = new HashMap<>();
    }
    
    public void setVariable(String variableName, Expression expression) {
        variables.put(variableName, expression);
    }
    
    public Expression getVariable(String variableName) {
        return variables.get(variableName);
    }
}

现在，我们可以在客户端中使用解释器模式来解析和执行表达式：

public class Client {
    public static void main(String[] args) {
        Context context = new Context();
        context.setVariable("x", new NumberExpression(5));
        context.setVariable("y", new NumberExpression(3));
        
        Expression expression = new AddExpression(
            context.getVariable("x"),
            new AddExpression(
                new NumberExpression(2),
                context.getVariable("y")
            )
        );
        
        int result = expression.interpret(context);
        System.out.println("Result: " + result);
    }
}

在上面的示例中，我们创建了一个上下文对象 context，并定义了两个变量 x 和 y。然后，我们构建一个复杂的表达式，包括两个加法操作和变量引用。最后，我们通过调用 interpret() 方法来解释和计算表达式的结果。

看了上面的demo，你可能还难以理解，下面再举一个在实际项目环境中的应用来说明。假设我们正在开发一个电子商务平台，其中包含一些促销活动。我们需要根据用户的购物车中的商品和其他条件来判断用户是否符合参与促销活动的资格。这时，我们可以使用解释器模式来解析和评估促销规则。

首先，我们定义抽象表达式接口 Expression：

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

然后，我们创建终结符表达式 ProductExpression，它表示购物车中是否存在指定的商品：

public class ProductExpression implements Expression {
    private String productName;
    
    public ProductExpression(String productName) {
        this.productName = productName;
    }
    
    public boolean interpret(Context context) {
        List<String> cartItems = context.getCartItems();
        return cartItems.contains(productName);
    }
}

接下来，我们创建非终结符表达式 AndExpression 和 OrExpression，分别表示逻辑与和逻辑或的关系：

public class AndExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;
    
    public AndExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }
    
    public boolean interpret(Context context) {
        return leftExpression.interpret(context) && rightExpression.interpret(context);
    }
}

public class OrExpression implements Expression {
    private Expression leftExpression;
    private Expression rightExpression;
    
    public OrExpression(Expression leftExpression, Expression rightExpression) {
        this.leftExpression = leftExpression;
        this.rightExpression = rightExpression;
    }
    
    public boolean interpret(Context context) {
        return leftExpression.interpret(context) || rightExpression.interpret(context);
    }
}

最后，我们定义上下文类 Context，它包含购物车中的商品和其他相关信息：

public class Context {
    private List<String> cartItems;
    // 其他上下文信息...
    
    public Context(List<String> cartItems) {
        this.cartItems = cartItems;
    }
    
    public List<String> getCartItems() {
        return cartItems;
    }
    
    // 其他上下文方法...
}

现在，我们可以在客户端中使用解释器模式来评估促销规则：

public class Client {
    public static void main(String[] args) {
        // 假设购物车中有 "item1" 和 "item2" 两个商品
        List<String> cartItems = Arrays.asList("item1", "item2");
        
        Context context = new Context(cartItems);
        
        Expression rule = new AndExpression(
            new ProductExpression("item1"),
            new OrExpression(
                new ProductExpression("item2"),
                new ProductExpression("item3")
            )
        );
        
        boolean isQualified = rule.interpret(context);
        if (isQualified) {
            System.out.println("符合参与促销活动的资格！");
        } else {
            System.out.println("不符合参与促销活动的资格。");
        }
    }
}

在上面的示例中，我们定义了购物车中的商品列表，创建了上下文对象 context，并构建了一个复杂的规则表达式，包括逻辑与和逻辑或的关系。最后，我们通过调用 interpret() 方法来评估促销规则是否符合条件。