Java 静态导入
通过实验,我发现 Java 非静态方法会覆盖范围内所有相同命名的方法,即使在静态上下文中也是如此。即使不允许参数重载。就像
import java.util.Arrays;
import static java.util.Arrays.toString;
public class A {
public static void bar(Object... args) {
Arrays.toString(args);
toString(args); //toString() in java.lang.Object cannot be applied to (java.lang.Object[])
}
}
我在规范中找不到任何关于此的信息。这是一个错误吗?如果不是,是否有任何理由实施这样的语言?
UPD:Java 6 不编译此示例。问题是 - 为什么?
Just by experiment I discovered that Java non static methods overrides all same named methods in scope even at static context. Even without allowing parameter overloading. Like
import java.util.Arrays;
import static java.util.Arrays.toString;
public class A {
public static void bar(Object... args) {
Arrays.toString(args);
toString(args); //toString() in java.lang.Object cannot be applied to (java.lang.Object[])
}
}
I can't find anything about this in spec. Is this a bug? If it isn't, are there any reasons to implement language like that?
UPD: Java 6 do not compile this example. The question is - why?
如果你对这篇内容有疑问,欢迎到本站社区发帖提问 参与讨论,获取更多帮助,或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱,如果其他用户或者作者回复了您的评论,将不能在第一时间通知您!
发布评论
评论(4)
解释很简单,但它并没有改变行为非常不直观的事实:
在解析要调用的方法时,编译器要做的第一件事就是找到具有正确名称的方法的最小封闭范围。然后才会出现其他事情,例如游戏中的重载解析和合作。
现在这里发生的事情是,包含 toString() 方法的最小封闭范围是从
Object
继承它的类 A。因此我们就停在那里,不再继续搜索。遗憾的是,接下来编译器尝试在给定范围内找到最适合的方法,并注意到它无法调用其中任何一个并给出错误。这意味着永远不要静态导入名称与 Object 中的方法相同的方法,因为自然在范围内的方法优先于静态导入(JLS 描述了方法遮蔽)详细,但对于这个问题,我认为记住这一点要简单得多)。
编辑:@alf 请提交 JLS 的正确部分,为那些想要了解整个情况的人描述了方法调用。这是相当复杂的,但问题也不简单,所以这是可以预料的。
The explanation is simple although it doesn't change the fact that the behavior is highly unintuitive:
When resolving the method to be invoked the first thing the compiler does is find the smallest enclosing scope that has a method of the right name. Only then come other things like overload resolution and co in game.
Now what is happening here is that the smallest enclosing scope that contains a
toString()
method is class A which inherits it fromObject
. Hence we stop there and don't search farther. Sadly next the compiler tries to find the best fit of the methods in the given scope and notices that it can't call any of those and gives an error.Which means never statically import methods with a name that is identical to a method in Object, because methods that are naturally in scope take precedence over static imports (the JLS describes method shadowing in detail, but for this problem I think it's much simpler to just remember that).
Edit: @alf kindly submitted the right part of the JLS that describes the method invocation for those who want the whole picture. It's rather complex, but then the problem isn't simple either so that's to be expected.
这不是覆盖。如果它确实有效,
this.toString()
仍然会访问A
的方法,而不是Arrays.toString
,就像重写时的情况一样已经发生了。语言规范解释说静态导入仅影响
static
方法和类型的解析:静态导入不会隐藏非静态方法或内部类型。
因此
toString
不会隐藏非静态方法。由于名称toString
可以引用A
的非静态方法,因此它不能引用Arrays< 的
static
方法/code> ,因此toString
绑定到范围内可用的唯一名为toString
的方法,即String toString()
。该方法不能接受任何参数,因此您会收到编译错误。第 15.12.1 节 解释了方法解析并会必须完全重写,以允许隐藏
static
方法中不可用的方法名称,但不能隐藏member
方法中的方法名称。我的猜测是,语言设计者希望保持方法解析规则简单,这意味着相同的名称无论是否出现在静态方法中都意味着相同的事情,唯一改变的是哪个可用。
It is not an override. If it did work,
this.toString()
would still access the method ofA
instead ofArrays.toString
as would be the case if overriding had occurred.The language specification explains that static imports only affect the resolution of
static
methods and types:Static imports do not shadow non-static methods or inner types.
So the
toString
does not shadow the non-static method. Since the nametoString
can refer to a non-static method ofA
, it does cannot refer to thestatic
method ofArrays
and thustoString
binds to the only method namedtoString
that is available in scope, which isString toString()
. That method cannot take any arguments so you get a compile error.Section 15.12.1 explains method resolution and would have to have been completely rewritten to allow shadowing of unavailable method names within
static
methods but not insidemember
methods.My guess is that the language designers wanted to keep method resolution rules simple, which means that the same name means the same thing whether it appears in a
static
method or not, and the only thing that changes is which are available.如果您尝试遵循类似的代码,那么您将不会收到任何编译器错误。
此代码可以编译而您的代码不能编译的原因是
toString()
(或 Object 类中定义的任何其他方法)的作用域仍然是 Object 类,因为 Object 是您的类的父类。因此,当编译器从 Object 类中找到这些方法的匹配签名时,它会给出编译器错误。在我的示例中,由于 Object 类没有sort(int[])
方法,因此编译器会将其与静态导入正确匹配。If you try following similar looking code then you will not get any compiler error
The reason this compiles and yours doesn't is that the
toString()
(or any other method defined in class Object) are still scoped to Object class because of Object being the parent of your class. Hence when compiler finds matching signature of those methods from Object class then it gives compiler error. In my example since Object class doesn't havesort(int[])
method hence compiler rightly matches it with the static import.我不认为这是一个错误或与正常导入不同的东西。例如,在正常导入的情况下,如果您有一个与导入的私有类同名的私有类,则导入的私有类将不会被反映。
I do not think it is a bug or something different from normal import. For example, in case of normal import, if you have a private class with the same name as imported one the imported one will not be reflected.