如何实现泛型抽象类？Java二叉树抽象设计的类型约束问题

云上老周

2026-5-28

如何在Java中设计类型安全的二叉搜索树抽象，避免非法继承？

我正在开发一个Java二叉搜索树项目，目标是先实现AVL树，同时要做好抽象设计，方便后续扩展红黑树等其他树结构。最开始我设计了抽象类BsNode（代表二叉搜索节点）和BsTree，然后通过AvlNode和AvlTree实现具体逻辑，代码大致如下：

public abstract class BsNode<T extends BsNode> { 
    T parent; 
    T left; 
    T right; 
    // 其他方法... 
} 

public abstract class BsTree<T extends BsNode> { 
    T root; 
    // 其他方法... 
} 

public class AvlNode extends BsNode<AvlNode> { 
    int balance; 
    // 其他方法... 
} 

public class AvlTree<AvlNode> { 
    private void rotate(int direction); 
    // 其他方法... 
}

但这带来了两个问题：

一是BsNode接收子类类型作为泛型参数的设计逻辑不够严谨；
二是会出现非法继承的情况，比如下面这些代码在编译时不会报错，但逻辑完全错误：

// 错误：RedBlackNode继承了BsNode<AvlNode>，类型不匹配
public class RedBlackNode extends BsNode<AvlNode> { ... }

// 错误：RedBlackNode实例的泛型参数是AvlNode
RedBlackNode myRoot = new RedBlackNode<AvlNode>();

我希望能在BsNode中强制要求父节点和子节点的类型就是继承它的类本身，而不是靠泛型参数随意传递。请问该怎么实现？

解决方案：使用自限定泛型（Self-bounding Generics）+ 编译时约束

要解决这个问题，核心是利用Java的自限定泛型来约束泛型参数必须是子类本身，同时通过一些技巧强化编译时检查，避免非法继承。

1. 修改抽象类的泛型定义

首先调整BsNode和BsTree的泛型边界，让泛型参数T必须继承自BsNode<T>，这样就能强制子类在继承时必须传入自身作为泛型参数：

// 自限定泛型：T必须是BsNode<T>的子类
public abstract class BsNode<T extends BsNode<T>> {
    protected T parent;
    protected T left;
    protected T right;

    // 受保护构造器，仅允许子类实例化
    protected BsNode() {}
}

// 同样给BsTree添加自限定泛型约束
public abstract class BsTree<T extends BsNode<T>> {
    protected T root;

    protected BsTree() {}
}

2. 实现具体子类

这样在实现AvlNode和AvlTree时，必须传入自身作为泛型参数，才能符合类型约束：

// 正确：AvlNode继承BsNode<AvlNode>，泛型参数是自身
public class AvlNode extends BsNode<AvlNode> {
    private int balance;

    public AvlNode() {
        super();
    }

    // 可以添加AVL节点特有的方法
    public int getBalance() {
        return balance;
    }

    public void setBalance(int balance) {
        this.balance = balance;
    }
}

// 正确：AvlTree继承BsTree<AvlNode>
public class AvlTree extends BsTree<AvlNode> {
    public void rotate(int direction) {
        // 旋转逻辑实现
    }
}

3. 阻止非法继承的额外手段

自限定泛型已经能在编译时对大部分非法继承给出警告或错误，但如果有人刻意写出RedBlackNode extends BsNode<AvlNode>这种代码，Java编译器不会直接报错（因为语法上符合泛型边界）。这时可以通过添加抽象方法来强化约束：

在BsNode中添加一个返回T类型的抽象方法，要求子类必须返回自身类型的实例：

public abstract class BsNode<T extends BsNode<T>> {
    // 原有字段和构造器...

    // 强制子类返回自身类型的节点实例
    public abstract T createNewNode();
}

那么AvlNode的实现会是：

public class AvlNode extends BsNode<AvlNode> {
    // 原有字段和构造器...

    @Override
    public AvlNode createNewNode() {
        return new AvlNode();
    }
}

如果有人尝试写RedBlackNode extends BsNode<AvlNode>，那么createNewNode方法必须返回AvlNode类型，但这显然不符合RedBlackNode的设计意图，开发者很容易发现这个错误，同时编译时也会因为逻辑矛盾（比如RedBlackNode的方法返回了其他类型）而暴露问题。

4. 运行时额外检查（可选）

如果需要更严格的约束，可以在BsNode的构造器中添加运行时检查，确保当前实例的类型和泛型参数T一致：

public abstract class BsNode<T extends BsNode<T>> {
    protected T parent;
    protected T left;
    protected T right;

    @SuppressWarnings("unchecked")
    protected BsNode() {
        // 检查当前实例是否属于T类型
        if (!(this instanceof BsNode<?> node) || !node.getClass().isInstance(this)) {
            throw new IllegalArgumentException("Concrete node class must pass itself as the generic type parameter");
        }
    }
}

这样如果有人非法继承，在实例化时会直接抛出运行时异常，及时发现问题。

效果验证

现在，当有人尝试写出非法继承的代码：

public class RedBlackNode extends BsNode<AvlNode> {
    // 必须实现createNewNode方法，但返回AvlNode显然不符合需求
    @Override
    public AvlNode createNewNode() {
        return new AvlNode(); // 这里逻辑明显错误，开发者会立刻发现
    }
}

这种代码要么在编译时就因为逻辑矛盾被开发者修正，要么在运行时抛出异常，彻底避免了非法类型的传递。

内容的提问来源于stack exchange，提问作者A. Kali