java - Java中的可扩展双链树实现

Question

我想通过一些额外的数据来扩展现有的双链树实现。

因此我可以重构基本的 TreeNode 实现，但我想有一个单独的扩展 TreeNode 实现，因为在我的现实世界场景中构建一个 ExtandedTreeNode 将比构建基本的 TreeNode 昂贵得多，并且仅某些用例需要额外的数据。

基本代码

这是我在 Java 中实现可扩展双链树的第一个基本方法:

基本树节点界面:

interface TreeNode
{
    // tree node getters:

    TreeNode getParent();

    List<? extends TreeNode> getChildren();

    // tree node setters:

    void setParent(TreeNode parentNode);

    void addChild(TreeNode childNode);

    // some basic operations:

    boolean isSelectable();

    // [...]
}

扩展树节点接口(interface):

interface ExtandedTreeNode extends TreeNode
{
    // narrow types of tree node getters of super-interface:

    @Override
    ExtandedTreeNode getParent();

    @Override
    List<? extends ExtandedTreeNode> getChildren();

    // narrowing types of tree node setters of super-interface is not possible!

    // some additional operations:

    boolean isRemoveable();

    // [...]
}

基本树节点实现:

class TreeNodeImpl implements TreeNode
{
    private TreeNode parent;

    private List<TreeNode> children = new ArrayList<TreeNode>();

    private boolean isSelectable;

    //
    // implement tree node getters:
    //

    @Override
    public TreeNode getParent()
    {
        return parent;
    }

    @Override
    public List<? extends TreeNode> getChildren()
    {
        return children;
    }

    //
    // implement tree node setters:
    //

    @Override
    public void setParent(TreeNode parent)
    {
        this.parent = parent;
    }

    @Override
    public void addChild(TreeNode childNode)
    {
        children.add(childNode);
    }

    //
    // implement basic operations:
    //

    @Override
    public boolean isSelectable()
    {
        return isSelectable;
    }

    // [...]
}

扩展树节点实现:

class ExtandedTreeNodeImpl implements ExtandedTreeNode
{
    private ExtandedTreeNode parent;

    private List<ExtandedTreeNode> children = new ArrayList<ExtandedTreeNode>();

    private TreeNode treeNode;

    private boolean isRemoveable;

    public ExtandedTreeNodeImpl()
    {
        treeNode = new TreeNodeImpl();
    }

    //
    // implement tree node getters:
    //

    @Override
    public ExtandedTreeNode getParent()
    {
        return parent;
    }

    @Override
    public List<? extends ExtandedTreeNode> getChildren()
    {
        return children;
    }

    //
    // implement tree node setters:
    //

    @Override
    public void setParent(TreeNode parent)
    {
        this.parent = (ExtandedTreeNode) parent; // <--- How to avoid this type cast!!
    }

    @Override
    public void addChild(TreeNode childNode)
    {
        children.add((ExtandedTreeNode) childNode); // <--- How to avoid this type cast!!
    }

    //
    // implement basic operations by delegating to composite TreeNode:
    //

    public boolean isSelectable()
    {
        return treeNode.isSelectable();
    }

    // [...]

    //
    // implement additional operations:
    //

    @Override
    public boolean isRemoveable()
    {
        return isRemoveable;
    }

    // [...]
}

问题

对我来说，类型层次结构对于只读和非特定于树节点的方法来说看起来很棒，但对于 setter setParent(..) 和 addChild(. .)。特别是对 ExtandedTreeNode 的风险类型转换非常邪恶，我想摆脱它。

我考虑过将 setParent(..) 和 addChild(..) 方法提取到另外两个单独的接口(interface)，如 TreeNodeWriteable 和 ExtandedTreeNodeWriteable，但也许有一些更好的设计方案。

有谁知道可以使用可写树节点特定 setter 解决我的问题的设计模式或蓝图？

Answer 1

您可以使用泛型。如下定义树节点:

interface TreeNode<N extends TreeNode> {

    N getParent();

    List<N> getChildren();

    void setParent(N parentNode);

    void addChild(N childNode);

}

现在您的 TreeNodeImpl 将如下所示: class TreeNodeImpl implements TreeNode<TreeNode>

而 ExtendedTreeNodeImpl 将定义如下:

class ExtendedTreeNodeImpl implements ExtendedTreeNode<ExtendedTreeNode>

这些类中的参数化方法将使用特定类型:TreeNode和 ExtendedTreeNode ，所以不需要类型转换。