Java 为什么会/应该允许这样做？

我知道并不是所有的WTF都是平等的，但为什么这是有效的呢。它确实会编译，并且只在您运行它时才会抱怨，因为它没有

static void main

方法，但除此之外，它在语法上是正确的。 我试着给它一个

main

方法，把它放在一个名为

\ java.java

的文件中，它确实运行了

class _<_>
{
    <_> _ _(_ _){ return (_)_; }
}

类_
{
_{return（{）}
}

显然，

类

中的“thing”是一个方法，它接受一个名称与其类型相同的参数，并返回它得到的任何参数。显然，

（）

是某种铸造。 但是我没有在

（\uuu）

之前得到零件。

---

我猜这个方法的名字是

。

，但是

。

是什么？如果它是泛型，那么它不应该是

\uu

？

替换为建议的“完全使用”。然后您可能会看到

\uu（\uu）

部分是

节点foo（Node Node）

。所以它实际上是方法名和返回类型

class Node<T> {

    <T> Node foo(Node node) {
        return (Node) node;
    }

    public static void main(String[] args) {
        Node<String> a = new Node();
        Node<String> b = new Node();
        a.foo(b);
    }
}

类节点{
节点foo（节点节点）{
返回（节点）节点；
}
公共静态void main（字符串[]args）{
节点a=新节点（）；
节点b=新节点（）；
a、 傅(乙);；
}
}

@ravindrab采取的方法是正确的，但结果并不正确

方法类型参数

（

）的声明（在原始源代码中）与类类型

节点的声明（
）形成阴影；因此，参数的类型是
T
，而不是
Node

method type参数还隐藏了类的type参数，因此为了避免混淆，最好给它一个不同的名称，比如

X

结果:

class Node<X> {
    <T> T foo(T t) {
        return (T) t;
    }
}

类节点{
T-foo（T-T）{
返回（T）T；
}
}

阴影的规则在中进行了解释。适用于本案的具体规定如下：

名为

n

的类型的声明

d

会隐藏任何 名为

n

的其他类型，在

d

发生点的范围内 在

d

的整个范围内

---

将

\uu

替换为类似

A

的内容，然后看看是否有意义……是的。我已经试过了，仍然没有在方法的开头得到

。我想如果你回答：“为什么不呢？”嗯。。。所以我想我从来没有这样写过泛型。我通常会把

节点

。好吧，就是这样。在Eclipse中验证这一点的一个更简单的方法是：转到cast

（）

）中的

，然后选择“opendeclaration”（F3）。光标将跳转到类型参数的定义；将
转换为该类型参数的类型。