Question

我需要创建一个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");
            }
        }
    }
}

Answer 1

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

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"));

Answer 2

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

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的实例;

Answer 3

试试这个。

public <T> TreeNode (Object... childs) {
  //code
}

Answer 4

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

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());
    }
  }

在可变长度参数列表中键入检查

4 个答案: