Java泛型问题：变量为null时如何判断泛型类型

原代码的核心问题是：在构造方法调用calculateValue时，成员变量value尚未赋值（处于null状态），此时通过value instanceof Integer或value.getClass()判断类型会直接抛出NullPointerException。同时Java泛型擦除导致运行时无法直接获取泛型T的实际类型，必须通过额外手段获取类型信息。

方案1：显式传入类型Class<T>（最直接可靠） #

在构造方法中新增Class<T>参数，直接通过Class对象判断类型，彻底摆脱对value的依赖。

修改后的完整代码：

import java.util.Collections;
import java.util.List;

public class TimeTreeNodeDTO<T extends Number> {
    private T value;
    private List<TimeTreeNodeDTO<T>> children;
    private PeriodType periodType;

    // 非叶子节点构造：传入周期类型、子节点集合、泛型类型Class
    public TimeTreeNodeDTO(PeriodType periodType, List<TimeTreeNodeDTO<T>> children, Class<T> type) {
        this.periodType = periodType;
        this.value = calculateValue(children, type);
        this.children = children;
    }

    // 叶子节点构造：直接传入周期类型和节点值
    public TimeTreeNodeDTO(PeriodType periodType, T value) {
        this.periodType = periodType;
        this.value = value;
        this.children = Collections.emptyList();
    }

    private T calculateValue(List<TimeTreeNodeDTO<T>> children, Class<T> type) {
        if (children == null || children.isEmpty()) {
            return null;
        }
        if (Integer.class.isAssignableFrom(type)) {
            int sum = children.stream().mapToInt(node -> node.getValue().intValue()).sum();
            return type.cast(Integer.valueOf(sum));
        } else if (Double.class.isAssignableFrom(type)) {
            double sum = children.stream().mapToDouble(node -> node.getValue().doubleValue()).sum();
            return type.cast(Double.valueOf(sum));
        } else {
            throw new IllegalArgumentException("Unsupported type: " + type.getName());
        }
    }

    public T getValue() {
        return value;
    }
}

实例化代码：

TimeTreeNodeDTO<Integer> wn1 = new TimeTreeNodeDTO<>(PeriodType.WEEK, List.of(
        new TimeTreeNodeDTO<>(PeriodType.DAY, 1),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 2),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 3),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 4),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 5),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 6),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 7)
), Integer.class);

优点：类型判断准确，不受value或子节点状态影响，逻辑清晰可靠。

方案2：从子节点获取类型（适用于非空子节点场景） #

如果能保证非叶子节点的子节点集合不为空，且第一个子节点的value不为null，可以直接从子节点获取类型信息，无需额外传参。

修改后的calculateValue方法：

private T calculateValue(List<TimeTreeNodeDTO<T>> children) {
    if (children == null || children.isEmpty()) {
        return null;
    }
    T firstChildValue = children.get(0).getValue();
    if (firstChildValue == null) {
        throw new IllegalStateException("First child has null value, cannot determine type");
    }
    Class<?> type = firstChildValue.getClass();
    if (Integer.class.isAssignableFrom(type)) {
        int sum = children.stream().mapToInt(node -> node.getValue().intValue()).sum();
        return (T) Integer.valueOf(sum);
    } else if (Double.class.isAssignableFrom(type)) {
        double sum = children.stream().mapToDouble(node -> node.getValue().doubleValue()).sum();
        return (T) Double.valueOf(sum);
    } else {
        throw new IllegalArgumentException("Unsupported type: " + type.getName());
    }
}

优点：无需额外传参，代码更简洁；缺点：依赖子节点状态，若子节点可能为空或存在null值则会报错，适用性有限。

方案3：策略模式（最优扩展方案） #

将不同类型的计算逻辑抽离为独立策略类，符合开闭原则，后续新增类型只需添加新策略，无需修改原有核心代码。

1. 定义计算策略接口：

import java.util.List;

public interface ValueCalculator<T extends Number> {
    T calculate(List<TimeTreeNodeDTO<T>> children);
}

2. 实现Integer和Double的计算策略：

import java.util.List;

public class IntegerValueCalculator implements ValueCalculator<Integer> {
    @Override
    public Integer calculate(List<TimeTreeNodeDTO<Integer>> children) {
        if (children == null || children.isEmpty()) {
            return null;
        }
        return children.stream().mapToInt(TimeTreeNodeDTO::getValue).sum();
    }
}

public class DoubleValueCalculator implements ValueCalculator<Double> {
    @Override
    public Double calculate(List<TimeTreeNodeDTO<Double>> children) {
        if (children == null || children.isEmpty()) {
            return null;
        }
        return children.stream().mapToDouble(TimeTreeNodeDTO::getValue).sum();
    }
}

3. 修改TimeTreeNodeDTO类：

import java.util.Collections;
import java.util.List;

public class TimeTreeNodeDTO<T extends Number> {
    private T value;
    private List<TimeTreeNodeDTO<T>> children;
    private PeriodType periodType;

    public TimeTreeNodeDTO(PeriodType periodType, List<TimeTreeNodeDTO<T>> children, ValueCalculator<T> calculator) {
        this.periodType = periodType;
        this.value = calculator.calculate(children);
        this.children = children;
    }

    public TimeTreeNodeDTO(PeriodType periodType, T value) {
        this.periodType = periodType;
        this.value = value;
        this.children = Collections.emptyList();
    }

    public T getValue() {
        return value;
    }
}

4. 实例化代码：

TimeTreeNodeDTO<Integer> wn1 = new TimeTreeNodeDTO<>(PeriodType.WEEK, List.of(
        new TimeTreeNodeDTO<>(PeriodType.DAY, 1),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 2),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 3),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 4),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 5),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 6),
        new TimeTreeNodeDTO<>(PeriodType.DAY, 7)
), new IntegerValueCalculator());

优点：代码解耦，扩展性强，新增类型（如Long、BigDecimal）只需实现新的ValueCalculator，无需改动TimeTreeNodeDTO核心逻辑。

内容的提问来源于stack exchange，提问作者Víctor Cardozo