如何在Java中将含括号或不含括号的逻辑表达式表示为对象？

1. 核心思路：拆分原子与复合条件 #

别再用单一类硬塞所有逻辑了，直接把表达式拆成两种核心类型：

• 原子条件：对应单个判断（比如），是表达式的最小单元
• 复合条件：用AND/OR组合多个子表达式，支持无限嵌套（比如(B OR (C AND D AND E))）

2. 代码实现示例 #

先定义一个抽象接口，所有表达式都得实现求值方法：

public interface Expression {
    boolean evaluate();
}

然后是原子条件类，处理单个判断逻辑：

public class AtomicCondition implements Expression {
    // 这里可以换成实际业务判断，比如检查某个字段状态
    private final boolean value;

    public AtomicCondition(boolean value) {
        this.value = value;
    }

    @Override
    public boolean evaluate() {
        return value;
    }
}

再做复合条件类，专门处理AND/OR组合，支持嵌套任意层级：

public enum LogicalOperator {
    AND, OR
}

public class CompositeCondition implements Expression {
    private final LogicalOperator operator;
    private final List<Expression> subExpressions;

    public CompositeCondition(LogicalOperator operator, List<Expression> subExpressions) {
        this.operator = operator;
        this.subExpressions = subExpressions;
    }

    @Override
    public boolean evaluate() {
        switch (operator) {
            case AND:
                return subExpressions.stream().allMatch(Expression::evaluate);
            case OR:
                return subExpressions.stream().anyMatch(Expression::evaluate);
            default:
                throw new IllegalArgumentException("未知操作符: " + operator);
        }
    }
}

3. 使用示例：构造复杂嵌套表达式 #

比如你要实现 <A AND (B OR (C AND D AND E))>，代码可以这么写：

public class Main {
    public static void main(String[] args) {
        // 定义各个原子条件
        Expression a = new AtomicCondition(true);
        Expression b = new AtomicCondition(false);
        Expression c = new AtomicCondition(true);
        Expression d = new AtomicCondition(true);
        Expression e = new AtomicCondition(true);

        // 层层嵌套构造复合表达式
        Expression cAndDAndE = new CompositeCondition(LogicalOperator.AND, List.of(c, d, e));
        Expression bOrNested = new CompositeCondition(LogicalOperator.OR, List.of(b, cAndDAndE));
        Expression finalExpr = new CompositeCondition(LogicalOperator.AND, List.of(a, bOrNested));

        // 直接求值
        System.out.println(finalExpr.evaluate()); // 输出 true
    }
}

4. 工具库推荐（省得自己写解析） #

如果需要把字符串形式的表达式（比如"A && (B || (C && D))"）转成可执行对象，不用自己写解析器，直接用现成库：

• Apache Commons JEXL：支持解析类似Java语法的表达式，逻辑运算、嵌套都能搞定
• MVEL：轻量级表达式语言，语法简洁，处理复杂逻辑表达式很顺手

举个JEXL的简单例子：

import org.apache.commons.jexl3.JexlEngine;
import org.apache.commons.jexl3.JexlExpression;

public class JexlExample {
    public static void main(String[] args) {
        JexlEngine jexl = new JexlEngine();
        String exprStr = "A && (B || (C && D && E))";
        JexlExpression expr = jexl.createExpression(exprStr);

        // 给表达式里的变量赋值
        var context = jexl.createContext();
        context.set("A", true);
        context.set("B", false);
        context.set("C", true);
        context.set("D", true);
        context.set("E", true);

        Boolean result = (Boolean) expr.evaluate(context);
        System.out.println(result); // 输出 true
    }
}

内容的提问来源于stack exchange，提问作者Mariza