Java空安全性设计咨询：如何实现null安全的ChangeListener？

这确实是Java里处理空值时的典型痛点——既要彻底避免NPE，又不想让API变得繁琐难用。咱们来拆解你的需求，看看几个方案的优劣，以及更优雅的替代思路：

先聊聊你现有的两个方案 #

1. 拆分三个方法的接口

public interface ChangeListener<T> {
    void valueSet(T current);
    void valueChanged(T previous, T current);
    void valueCleared(T previous);
}

这个方案的优点是语义极度清晰，调用方完全不用猜参数是否为空，每种变更场景都有明确的方法对应。但你担心的繁琐问题确实存在——如果实现类只关心其中一种变化，就得被迫实现另外两个空方法。

不过这个问题可以用Java 8+的默认方法缓解：

public interface ChangeListener<T> {
    default void valueSet(T current) {}
    default void valueChanged(T previous, T current) {}
    default void valueCleared(T previous) {}
}

这样实现类只需要重写自己关心的方法，冗余代码就没了，语义清晰的优势也保留了。

2. 使用Optional<T>作为参数

public interface ChangeListener<T> {
    void changed(Optional<T> previous, Optional<T> current);
}

这个方案的优点是接口足够简洁，只用一个方法就能覆盖所有场景，而且Optional是Java官方推荐的空值替代方案，语义明确（Optional.empty()直接代表"无值"，比null直观得多）。

你提到的装箱开销确实存在，但仅当T是基本类型时才会有明显影响——如果你的场景里基本类型用得不多，这个性能损耗几乎可以忽略。而且调用时可以用流式API简化判断：

ChangeListener<String> listener = (prev, curr) -> {
    if (prev.isEmpty() && curr.isPresent()) {
        // 处理从无到有的场景
        System.out.println("Value set to: " + curr.get());
    } else if (prev.isPresent() && curr.isPresent()) {
        // 处理值变更场景
        System.out.println("Changed from " + prev.get() + " to " + curr.get());
    } else if (prev.isPresent() && curr.isEmpty()) {
        // 处理从有到无的场景
        System.out.println("Value cleared, was: " + prev.get());
    }
};

更优雅的进阶方案：密封类+代数数据类型（Java 17+） #

如果你的项目用的是Java 17及以上，可以用密封类来定义变更的三种状态，既保证类型安全，又完全避免null和装箱：

首先定义一个密封的变更类型：

public sealed interface ValueChange<T> permits ValueSet, ValueChanged, ValueCleared {
    record ValueSet<T>(T current) implements ValueChange<T> {}
    record ValueChanged<T>(T previous, T current) implements ValueChange<T> {}
    record ValueCleared<T>(T previous) implements ValueChange<T> {}
}

然后修改ChangeListener接口：

public interface ChangeListener<T> {
    void changed(ValueChange<T> change);
}

调用时可以用switch表达式（Java 14+支持）来处理，代码非常简洁且类型安全：

ChangeListener<String> listener = change -> {
    switch (change) {
        case ValueSet<String> vs -> System.out.println("Value set to: " + vs.current());
        case ValueChanged<String> vc -> System.out.println("Changed from " + vc.previous() + " to " + vc.current());
        case ValueCleared<String> vcl -> System.out.println("Value cleared, was: " + vcl.previous());
    }
};

这个方案的优势是完全没有空值风险，语义清晰到不用看文档，而且编译器会强制你覆盖所有变更场景，不会遗漏分支。唯一的限制是需要Java 17+的密封类支持。

关于空对象模式的补充 #

你提到空对象模式需要扩展类的问题，其实可以用泛型静态实例来优化，避免每个类都要扩展：

public class NullObject<T> {
    private static final NullObject<?> INSTANCE = new NullObject<>();
    
    @SuppressWarnings("unchecked")
    public static <T> NullObject<T> getInstance() {
        return (NullObject<T>) INSTANCE;
    }
}

这样不管T是什么类型，都可以用NullObject.getInstance()作为空值替代，但这个方案的局限性也很明显——如果你的值类型是第三方类或者基本类型，就不太适用，而且调用方需要额外学习这个空对象的使用方式。

最后给个选择建议 #

• 如果你追求兼容性和简洁性：用Optional的方案最稳妥，虽然有轻微装箱，但大部分场景下性能影响可以忽略，而且是Java标准方案，学习成本低。
• 如果你追求极致类型安全和语义清晰：且项目用Java 17+，密封类的方案是最佳选择，完全避免NPE，代码也足够优雅。
• 如果你希望接口语义直观，不想引入额外类：用带默认方法的三个方法接口，调用方可以按需实现，冗余代码也很少。

内容的提问来源于stack exchange，提问作者clay-golem