Java泛型深度应用：构建类型安全的表达式树解析器

        实现一个类型安全的表达式树解析器，能够编译和计算数学表达式、逻辑表达式，并支持自定义函数和变量。

1. 表达式接口和基础实现

public interface Expression<T> {
    T evaluate();
    Class<T> getType();
}

// 常量表达式
public class ConstantExpression<T> implements Expression<T> {
    private final T value;
    
    public ConstantExpression(T value) {
        this.value = value;
    }
    
    @Override
    public T evaluate() {
        return value;
    }
    
    @Override
    public Class<T> getType() {
        @SuppressWarnings("unchecked")
        Class<T> type = (Class<T>) value.getClass();
        return type;
    }
}

// 变量表达式
public class VariableExpression<T> implements Expression<T> {
    private final String name;
    private final Class<T> type;
    
    public VariableExpression(String name, Class<T> type) {
        this.name = name;
        this.type = type;
    }
    
    @Override
    public T evaluate() {
        throw new UnsupportedOperationException("Variable must be bound before evaluation");
    }
    
    @Override
    public Class<T> getType() {
        return type;
    }
    
    public String getName() {
        return name;
    }
}

2. 复杂泛型操作表达式

// 二元操作抽象类
public abstract class BinaryOperation<L, R, T> implements Expression<T> {
    protected final Expression<L> left;
    protected final Expression<R> right;
    
    public BinaryOperation(Expression<L> left, Expression<R> right) {
        this.left = left;
        this.right = right;
    }
    
    @Override
    public abstract T evaluate();
    
    @Override
    public abstract Class<T> getType();
}

// 加法操作
public class AddOperation extends BinaryOperation<Number, Number, Number> {
    public AddOperation(Expression<Number> left, Expression<Number> right) {
        super(left, right);
    }
    
    @Override
    public Number evaluate() {
        Number l = left.evaluate();
        Number r = right.evaluate();
        
        if (l instanceof Double || r instanceof Double) {
            return l.doubleValue() + r.doubleValue();
        } else if (l instanceof Float || r instanceof Float) {
            return l.floatValue() + r.floatValue();
        } else if