Java中如何使子类成员类型为自身类型而非父类类型？

这个问题其实可以通过泛型类来完美解决，既保证parent的类型和子类一致，又能优雅地扩展UnionFind的功能。我一步步给你拆解：

1. 将基类Node改造为泛型类 #

要让子类的parent类型和自身绑定，核心是给Node类引入泛型参数，限定它为Node的子类。这样每个子类都可以把自己作为类型参数传入基类，让parent的类型精准匹配：

class Node<T extends Node<T>> {
    T parent;
    int rank;

    public Node() {
        // 这里的强转是安全的，因为子类实例化时T就是子类本身
        this.parent = (T) this;
        this.rank = 0;
    }
}

泛型参数T extends Node<T>是关键——它保证了T必须是Node的子类，同时让基类中的parent类型和子类强绑定。

2. 定义带扩展属性的子类 #

比如你需要添加V value并记录最小值，我们可以创建一个ValueNode子类，指定泛型参数为自身：

class ValueNode<V> extends Node<ValueNode<V>> {
    V value;
    V minValue; // 用于存储当前集合的最小值

    public ValueNode(V value) {
        super();
        this.value = value;
        // 初始状态下，集合只有自己，最小值就是自身value
        this.minValue = value;
    }
}

这样ValueNode的parent属性类型就是ValueNode<V>，而不是父类Node，后续操作时不需要强制类型转换，代码更安全简洁。

3. 扩展UnionFind实现最小值记录功能 #

基于泛型Node子类，我们可以改造UnionFind的find和merge方法，同时维护集合的最小值：

class UnionFind<V extends Comparable<V>> {
    // 路径压缩的find方法，同时保证parent类型正确
    public ValueNode<V> find(ValueNode<V> node) {
        if (node.parent != node) {
            node.parent = find(node.parent); // 递归路径压缩
        }
        return node.parent;
    }

    // 按rank合并，同时更新集合的最小值
    public void merge(ValueNode<V> a, ValueNode<V> b) {
        ValueNode<V> rootA = find(a);
        ValueNode<V> rootB = find(b);
        
        if (rootA == rootB) return; // 已经在同一个集合，无需合并

        // 按rank合并，保证树的高度尽可能小
        if (rootA.rank < rootB.rank) {
            rootA.parent = rootB;
            // 更新rootB的最小值为两个集合最小值的较小者
            rootB.minValue = getMin(rootB.minValue, rootA.minValue);
        } else {
            rootB.parent = rootA;
            rootA.minValue = getMin(rootA.minValue, rootB.minValue);
            // 如果rank相等，合并后rootA的rank+1
            if (rootA.rank == rootB.rank) {
                rootA.rank++;
            }
        }
    }

    // 辅助方法：获取两个值的最小值（假设V实现了Comparable）
    private V getMin(V a, V b) {
        return a.compareTo(b) < 0 ? a : b;
    }
}

使用示例 #

public class Main {
    public static void main(String[] args) {
        UnionFind<Integer> uf = new UnionFind<>();
        ValueNode<Integer> node1 = new ValueNode<>(5);
        ValueNode<Integer> node2 = new ValueNode<>(3);
        ValueNode<Integer> node3 = new ValueNode<>(7);

        uf.merge(node1, node2);
        // 查找node1所在集合的最小值
        System.out.println(uf.find(node1).minValue); // 输出3

        uf.merge(node2, node3);
        System.out.println(uf.find(node3).minValue); // 输出3
    }
}

额外说明 #

如果后续需要其他扩展（比如添加权重、计数等），只需要按照同样的模式创建子类即可：

class WeightedNode extends Node<WeightedNode> {
    int weight;
    int count; // 记录集合大小

    public WeightedNode(int weight) {
        super();
        this.weight = weight;
        this.count = 1;
    }
}

这种泛型设计既解决了parent类型匹配的问题，又保持了代码的扩展性，完全适配UnionFind的功能扩展需求。

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