如何在Java中为泛型类有条件地实现接口

我有一个容器类：

class Container<T> {
    private T content;

    // 其他字段和方法
}

我希望Container<T>实现Comparable<Container<T>>，但这仅在T实现Comparable<? super T>时才有意义。我不想给T添加该约束，因为Container需要兼容未实现Comparable的类型。

我想到的方案是把content改为protected并创建子类：

class ComparableContainer<T extends Comparable<? super T>> extends Container<T>
        implements Comparable<ComparableContainer<T>> {

    @Override
    public int compareTo(ComparableContainer<T> other) {
        return this.content.compareTo(other.content);
    }
}

但这个方案存在两个问题：

• 缺乏安全的方式将Container<T extends Comparable<? super T>>转换为ComparableContainer<T>
• 将content设为protected会让Container的所有子类都能访问该字段，破坏了封装性

方案1：组合替代继承，保留封装性 #

放弃继承关系，让ComparableContainer持有Container<T>实例，同时实现Comparable接口。这种方式无需修改原Container的访问权限，还能安全包装已有实例：

class ComparableContainer<T extends Comparable<? super T>> implements Comparable<ComparableContainer<T>> {
    private final Container<T> container;

    // 直接创建带内容的包装实例
    public ComparableContainer(T content) {
        this.container = new Container<>(content);
    }

    // 静态方法：安全包装已有Container实例
    public static <T extends Comparable<? super T>> ComparableContainer<T> wrap(Container<T> container) {
        // 要求原Container提供获取content的公共方法，比如getContent()
        return new ComparableContainer<>(container.getContent());
    }

    @Override
    public int compareTo(ComparableContainer<T> other) {
        return container.getContent().compareTo(other.container.getContent());
    }

    // 按需转发Container的其他公共方法
    public T getContent() {
        return container.getContent();
    }
}

优势：

• 完全保留Container的封装性，无需修改原有字段权限
• 通过wrap方法在编译时确保类型安全，仅接受T为Comparable的Container实例

方案2：在Container中添加安全转换逻辑，保留继承关系 #

如果希望保留继承，可以在Container中添加包私有方法供ComparableContainer访问content，同时提供静态转换方法确保类型安全：

首先修改Container类：

class Container<T> {
    private T content;

    public Container(T content) {
        this.content = content;
    }

    // 包私有方法，仅允许同包的ComparableContainer访问
    T getContentInternal() {
        return content;
    }

    // 其他字段和方法

    // 静态转换方法，编译时约束T必须实现Comparable
    public static <T extends Comparable<? super T>> ComparableContainer<T> toComparable(Container<T> container) {
        return new ComparableContainer<>(container);
    }
}

然后修改ComparableContainer类：

class ComparableContainer<T extends Comparable<? super T>> extends Container<T>
        implements Comparable<ComparableContainer<T>> {

    // 私有构造方法，仅通过Container.toComparable创建实例
    private ComparableContainer(Container<T> container) {
        super(container.getContentInternal());
    }

    @Override
    public int compareTo(ComparableContainer<T> other) {
        return this.getContentInternal().compareTo(other.getContentInternal());
    }
}

优势：

• content保持私有，仅Container和同包的ComparableContainer能访问
• 转换过程由Container.toComparable统一管控，编译时就能确保T的类型合法性，避免运行时错误
• 继承关系保留，ComparableContainer可直接复用Container的所有公共方法

方案3：动态代理（不推荐） #

如果无法修改原Container类，可通过动态代理在运行时生成实现Comparable的代理对象，但这种方式实现复杂，存在性能开销，仅作为极端场景的备选方案。

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