如何用Java 8优化带括号的逻辑表达式对象结构实现？

你的核心问题在于原有的类结构没法处理嵌套/组合式的表达式——括号里的内容本质上就是一个完整的逻辑单元，既可以是单个条件，也可以是另一个由AND/OR连接的表达式。用组合模式就能完美解决这个问题，让我们把表达式结构设计成“叶子节点（单个条件）+ 组合节点（逻辑运算组）”的树形结构，既简洁又能支持任意层级的嵌套。

重构后的类结构 #

我们重新设计一下类层次：

1. 抽象基类Operand：作为所有表达式元素的统一接口/父类
2. 叶子节点Condition：表示单个原子条件（比如A、B这类）
3. 组合节点LogicalExpression：表示由AND/OR连接的一组操作数（可以是Condition，也可以是另一个LogicalExpression）

代码实现如下：

import java.util.List;

// 抽象操作数：所有表达式元素的父类
abstract class Operand {}

// 原子条件：叶子节点，对应单个条件如A、B
class Condition extends Operand {
    private final String type;
    private final Object value;

    public Condition(String type, Object value) {
        this.type = type;
        this.value = value;
    }

    // 可选：添加获取方法
    public String getType() { return type; }
    public Object getValue() { return value; }
}

// 逻辑表达式：组合节点，用来表示AND/OR连接的多个操作数（支持嵌套）
class LogicalExpression extends Operand {
    private final Operator operator;
    private final List<Operand> operands;

    // 构造器直接接收运算符和操作数列表
    public LogicalExpression(Operator operator, List<Operand> operands) {
        this.operator = operator;
        this.operands = operands;
    }

    // 静态工厂方法，让表达式构建更简洁流畅
    public static LogicalExpression of(Operator operator, Operand... operands) {
        return new LogicalExpression(operator, List.of(operands));
    }

    // 可选：添加获取方法
    public Operator getOperator() { return operator; }
    public List<Operand> getOperands() { return operands; }
}

// 运算符枚举
enum Operator { AND, OR }

为什么这个结构能解决括号问题？ #

括号里的任何表达式本身就是一个Operand：

• 如果括号里是单个条件（比如(A)），那它就是一个Condition对象
• 如果括号里是组合表达式（比如(A AND B)），那它就是一个LogicalExpression对象

这样不管嵌套多少层括号，都能完美表示——因为每一层括号都是一个Operand，可以作为上层LogicalExpression的操作数。

示例：构建你给出的复杂表达式 #

现在我们来构建((A and B) or (C or(D and (E or F and G) and H)))：

// 先构建最内层的(F AND G)
LogicalExpression fAndG = LogicalExpression.of(Operator.AND, new Condition("F", true), new Condition("G", true));

// 然后构建(E OR (F AND G))
LogicalExpression eOrFAndG = LogicalExpression.of(Operator.OR, new Condition("E", true), fAndG);

// 接着构建(D AND (E OR F AND G) AND H)
LogicalExpression dAndEOrFAndGAndH = LogicalExpression.of(Operator.AND,
        new Condition("D", true),
        eOrFAndG,
        new Condition("H", true));

// 再构建(C OR (D AND ...))
LogicalExpression cOrDAndEtc = LogicalExpression.of(Operator.OR,
        new Condition("C", true),
        dAndEOrFAndGAndH);

// 构建(A AND B)
LogicalExpression aAndB = LogicalExpression.of(Operator.AND, new Condition("A", true), new Condition("B", true));

// 最终组合成整个表达式
LogicalExpression finalExpression = LogicalExpression.of(Operator.OR, aAndB, cOrDAndEtc);

额外优化：添加求值方法（可选） #

如果需要对表达式求值，可以给Operand添加抽象的evaluate()方法，让每个子类实现自己的求值逻辑：

abstract class Operand {
    public abstract boolean evaluate();
}

class Condition extends Operand {
    // ... 原有代码 ...
    @Override
    public boolean evaluate() {
        // 这里根据type和value返回对应的布尔值，比如假设value是Boolean类型
        return (Boolean) value;
    }
}

class LogicalExpression extends Operand {
    // ... 原有代码 ...
    @Override
    public boolean evaluate() {
        return switch (operator) {
            case AND -> operands.stream().allMatch(Operand::evaluate);
            case OR -> operands.stream().anyMatch(Operand::evaluate);
        };
    }
}

这样调用finalExpression.evaluate()就能直接得到整个表达式的布尔结果啦。

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