Question

我有一个应用程序在节点和边G（N，E）的图上执行各种分析算法。节点和边的属性随应用程序而变化，并根据图的类型和属性的性质形成继承层次结构。例如，Node层次结构的根可以表示最一般的非定向循环图（NcgNode）。 NcgNode的子类可以表示有向循环图（DcgNode），然后是DagNode等。可以应用于DAG的算法与NCG的算法不同，但反之亦然。树的根的关键行为是添加和检索图的相邻节点。问题是如何在不创建“未经检查”的例外的情况下执行此操作？

简洁版的代码可能如下所示：

import java.util.ArrayList;
import java.util.List;

public class NcgNode {
    private List<NcgNode> nodeList_ = null;
    private List<? extends NcgNode> nodeListSrc_ = null;
    private List<? super NcgNode> nodeListSink_ = null;

    public <N extends NcgNode> void addNode(N node) {
        if (nodeList_ == null) {
            nodeList_ = new ArrayList<NcgNode>();
            nodeListSrc_ = nodeList_;
            nodeListSink_ = nodeList_;
        }
        nodeListSink_.add(node);
    }

    @SuppressWarnings("unchecked")
    // Any way to avoid this?
    public <N extends NcgNode> N getNode(int n) {
        if ((nodeList_ == null) || (n >= nodeList_.size()))
            return null;
        // causes unchecked warning:
        return (N) nodeListSrc_.get(n);
    }
}

class DcgNode extends NcgNode {
    // enables DCG algorithms, etc
}

class DagNode extends DcgNode {
    // enables DAG algorithms, etc.
}

有没有更好的方法来设计它？

Answer 1

只需让你的列表有类型NcgNode，例如

private List<NcgNode> nodeListSrc_ = null;

您仍然可以将NcgNode的子类放入这些列表中。

Answer 2

你应该这样做，如下所示。具有在抽象类（NcgNode）中定义的方法，并根据子类型进行参数化。因此，addNode和getNode可以轻松编写。然后你将有特定的实现（我使用DcgNode和DagNode;不确定这是否是你想要的）作为它的子类，参数化自身。这允许您稍后（见下文）算法要求节点的子节点与节点的类型相同。

public abstract class NcgNode<N> {
    private List<N> nodeList_ = null;

    public void addNode(N node) {
        if (nodeList_ == null) {
            nodeList_ = new ArrayList<N>();
        }
        nodeList_.add(node);
    }

    // Any way to avoid this?
    public N getNode(int n) {
        if ((nodeList_ == null) || (n >= nodeList_.size()))
            return null;
        return nodeList_.get(n);
    }
}

class DcgNode extends NcgNode<DcgNode> {
    // enables DCG algorithms, etc
}

class DagNode extends NcgNode<DagNode> {
    // enables DAG algorithms, etc.
}

//...
static <N extends NcgNode<N>> void someAlgorithm(N node) { }

您认为DagNode是DcgNode的子类是不安全的，因为如果DagNode“是”DcgNode，那么这意味着您可以放任何DcgNode作为它的孩子进入它，这不是你想要的。

Answer 3

修改您的方法如下：

public NcgNode getNode(int n) {
  if ((nodeList_ == null) || (n >= nodeList_.size())) {
  return null;
}

return (NcgNode) nodeListSrc_.get(n);
}

Answer 4

查看“自我绑定类型”。（编辑：不确定我理解这里的低票）

您的根类应该是抽象的，实际节点类型N应该是类的类型参数，如

public abstract class AbstractNode< N extends AbstractNode< N > > {
    private List< N > nodeList_ = null;

    public synchronized void addNode( N node ) {
        if ( nodeList_ == null )
            nodeList_ = new ArrayList< N >();
        nodeList_.add(node);
    }

    public N getNode( int n ) {
        if ( nodeList_ == null || n >= nodeList_.size() )
            throw new NoSuchElementException();
        return nodeList_.get( n );
    }
}

然后，具体的子类可以将它们自己的类型提供为N.对于深层继承层次结构，请将“我的类型”保持为另一个抽象类。

class NcgNode extends AbstractNode< NcgNode > {
}

abstract class AbstractDcgNode< N extends AbstractDcgNode< N > > extends AbstractNode< N > {
    // enables DCG algorithms, etc
}

class DcgNode extends AbstractDcgNode< DcgNode > {
}

class DagNode extends AbstractDcgNode< DagNode > {
    // enables DAG algorithms, etc
}

继承和泛型

4 个答案: