Java 泛型推送到堆栈会导致编译错误

我有一个节点类，定义如下-

public static class Node<T> {
    public T value;
    public Node<T> left;
    public Node<T> right;

    public Node(T value) {
        this.value = value;
        left = null;
        right = null;
    }

}

公共静态类节点{
公共价值观；
公共节点左；
公共节点权；
公共节点（T值）{
这个值=值；
左=空；
右=空；
}
}

现在，我正试图将

节点添加/推送到
堆栈
，这会给我一个编译错误

private static <T> Node<T> createTree(Expression expression) {
    Stack<Node<T>> nodeStack = new Stack<>();
    Stack<Token> tokenStack = new Stack<>();

    Token token = getNextToken(expression);

    while (token != null) {
        if (token instanceof OpenParenthesis) {
            tokenStack.push(token);
        } else if (token instanceof Element) {
            nodeStack.push(new Node<Integer>(((Element) token).value)); // Here
        } else if (token instanceof EmptyElement) {
            nodeStack.push(null);
        } else if (token instanceof CloseParenthesis) {
            if (nodeStack.size() == 1) {
                tokenStack.pop();
                return nodeStack.pop();
            }

            tokenStack.pop();
            Node<T> right = nodeStack.pop();
            Node<T> left = nodeStack.pop();
            Node<T> node = nodeStack.pop();
            node.left = left;
            node.right = right;
            nodeStack.push(node);
        }

        token = getNextToken(expression);
    }

    return null;
}

私有静态节点createTree（表达式）{
堆栈节点堆栈=新堆栈（）；
Stack tokenStack=新堆栈（）；
Token-Token=getNextToken（表达式）；
while（令牌！=null）{
if（Open括号的令牌实例）{
tokenStack.push（令牌）；
}else if（元素的令牌实例）{
nodeStack.push（新节点（（（元素）标记）.value））；//此处
}else if（清空的令牌实例）{
nodeStack.push（空）；
}else if（闭合括号的标记实例）{
如果（nodeStack.size（）==1）{
tokenStack.pop（）；
返回nodeStack.pop（）；
}
tokenStack.pop（）；
Node right=nodeStack.pop（）；
Node left=nodeStack.pop（）；
Node=nodeStack.pop（）；
node.left=左；
node.right=右；
nodeStack.push（节点）；
}
token=getNextToken（表达式）；
}
返回null；
}

这行代码无法编译-

nodeStack.push(new Node<Integer>(((Element) token).value));

nodeStack.push（新节点（（（元素）令牌）.value））；

带着信息-

堆栈中的
推送（节点）
无法应用于
（节点）

类型参数是方法级参数。即，您在方法签名处定义了它：

private static <T> Node<T> createTree(Expression expression

嗯，是的
T
可以是任何类型，例如
String
。如果它是一个
字符串
，您希望如何将整数推送到堆栈上？我怀疑您可能不希望
createTree
是泛型的；也许它应该返回一个
节点
，这样您就可以创建一个包含不同类节点的树。另外，为什么您要将
标记
强制转换为
编号
？这不会编译。糟糕的是，我有一个本地类
Number
，我在这里没有提到。我将对它进行重命名以消除混淆。您应该避免将类型命名为与JavaAPI中相同的类型，尤其是​ 在
java.lang…
和
java.util…
包系列中。你刚才看到为什么了。源代码是为人类编写的。尊重人类。我知道我可以让
createTree（）
返回一个
节点
，但有时，我可以使用
字符串
而不是
整数
。我必须创建一个单独的
createTree（）
来返回一个
节点
。如果在编译时知道它是
String
还是
Integer
，那么可以使用类型化方法，即使用
nodeStack.push（新节点（（元素）标记）.value）的方法。在这种情况下，您可以像这样指定
类型：
OuterClass.createTree（…）
或
OuterClass.createTree（…）
。您可以看看这个问题吗？我已经添加了更多详细信息。这可能会澄清我想说的话。我不想在这里编辑这个问题（它可能会改变我以前提出的问题）。有关完整的解决方案，请参阅。@yadav_vi您是否正在尝试创建一个树，其中可以同时包含
String
和
Integer
节点？
Stack<Node<T>> nodeStack = new Stack<>();

nodeStack.push(new Node<T>(((Element) token).value));
//                   ^^^^^^ - using <T>

private static Node<Integer> createTree(Expression expression) {
    Stack<Node<Integer>> nodeStack = new Stack<>();
    // ...
    } else if (token instanceof Element) {
         nodeStack.push(new Node<Integer>(((Element) token).value)); // Here
    }
    // ...
            Node<Integer> right = nodeStack.pop();
            Node<Integer> left = nodeStack.pop();
            Node<Integer> node = nodeStack.pop();
    // ...
    }
}