1

我需要创建一个 TreeNode 类，它将能够存储两种类型的子节点：String 和 TreeNode。孩子的数量不固定。

我想以某种方式创建 TreeNode 对象，如下所示：

TreeNode a = new TreeNode("str", new TreeNode("str2"), "str3"); //Correct
TreeNode b = new TreeNode(a, "str4); //Correct
TreeNode c = new TreeNode(54); //Wrong

如何在编译时使用通配符或其他东西进行参数类型检查？

我不合适的运行时解决方案：

private static final boolean debug = "true".equals(System.getProperty("debug"));

public <T> TreeNode (T... childs) {
    if (debug) {
        for (Object child : childs) {
            if (!(child instanceof String || child instanceof TreeNode)) {
                throw new RuntimeException("Type of childs must me Tree or String");
            }
        }
    }
}
4

4 回答 4

2

您应该尝试找到可以添加到树中的单一基本类型。然后，从中派生您的具体节点类型：

abstract class Node { }
class TreeNode extends Node {
  public TreeNode(Node... children) {
    // ...
  }
}
class StringNode extends Node { 
  public StringNode(String value) {
    // ...
  }
}

用法：

TreeNode a = new TreeNode(
  new StringNode("str"), 
  new TreeNode(new StringNode("str2")), 
  new StringNode("str3"));
于 2012-07-11T19:32:47.653 回答
2

构造函数中的参数应该具有特殊含义。使用可变参数是可以接受的，但它认为这些是特殊情况。你的问题可以用另一种方式解决。

public class TreeNode {

   public TreeNode() {
     //crate the object
   }

   public TreeNode addNode(String node, String... nodes) {
    //Do something with string node
    return this;
   }

   public TreeNode addNode(TreeNode node, TreeNode... nodes) {
   //Do something with TreeNode
    return this;
   }
}

所以你可以像这样使用它，例如

TreeNode node = new TreeNode().addNode("One","Two").addNode(node3,node4);

其中 node3 和 node4 是 TreeNode 的实例；

于 2012-07-11T19:41:56.233 回答
0

试试这个。

public <T> TreeNode (Object... childs) {
  //code
}
于 2012-07-11T19:31:35.637 回答
0

如果你仍然想移植某种程度的编译时类型安全，你可以这样做：

public class AorB<A, B> {
  private final Object _instance;
  private final boolean _isA;

  public AorB(A instance) {
    _instance = instance;
    _isA = true;
  }

  public AorB(B instance) {
    _instance = instance;
    _isA = false;
  }

  public A asA() {
    assert _isA;
    return (A) _instance;
  }

  public B asB() {
    assert !_isA;
    return (B) _instance;
  }

  public boolean isA() {
    return _isA;
  }
}

然后使用AorB<String, TreeNode>实例。

asB()请注意，如果您不喜欢当实例为 时有人可能会这样做，您可以走得更远，也可以有一个类型安全的回调A：

public class AorB<A, B> {
  ...
  public interface Handler<A, B> {
    void handle(A instnace);
    void handle(B instance);
  }

  public void handle(Handler<A, B> handler) {
    if (isA()) {
      handler.handle(asA());
    } else {
      handler.handle(asB());
    }
  }
于 2012-07-11T19:37:11.110 回答