是否可以在不重新编译的情况下使用库重载方法？
假设库中有一个方法
public static <E> void doSmth(Collection<E> foo, Collection<E> bar){...}
，并且在以下代码中使用了它：
Set<Object> foo = ...;
List<Object> bar = ...;
doSmth(foo, bar);
现在库的另一个版本在类路径中替换了前者，并且它有两个方法：
public static <E> void doSmth(Collection<E> foo, Collecion<E> bar){...}
public static <E> void doSmth(Set<E> foo, List<E> bar){...}
应用程序不重新编译和运行。将使用哪种方法？
Say there was a method in the library
public static <E> void doSmth(Collection<E> foo, Collection<E> bar){...}
and it was used in the following code:
Set<Object> foo = ...;
List<Object> bar = ...;
doSmth(foo, bar);
Now another version of library substitues the former in the classpath and it has two methods:
public static <E> void doSmth(Collection<E> foo, Collecion<E> bar){...}
public static <E> void doSmth(Set<E> foo, List<E> bar){...}
The application is not recompiled and run. Which method will be used?
如果你对这篇内容有疑问，欢迎到本站社区发帖提问 参与讨论，获取更多帮助，或者扫码二维码加入 Web 技术交流群。
绑定邮箱获取回复消息
由于您还没有绑定你的真实邮箱，如果其他用户或者作者回复了您的评论，将不能在第一时间通知您！
发布评论
评论（3）
重载解析是一个编译时过程，因此如果不重新编译，其结果就不会改变。
因此，
将使用它，因为它的签名是在编译文件中指定的。
Overload resolution is a compile-time process, therefore its result can't change without recompilation.
So,
will be used, since its signature is specified in the compiled file.
如果类路径中有同一个库的 2 个版本，则很难判断类加载器将首先加载哪一个（因此将使用哪一个）——事实上，结果很可能因机器和 JVM 的不同而不同。
如果您确实需要先加载某个版本，可以通过命令行中的
-Xbootclasspath参数将其添加到bootclasspath中。If you have 2 versions of the same library in the classpath it's hard to tell which one would the classloader load first (and therefore which one it would use) -- in fact chances are results will differ from machine to machine and JVM to JVM.
If you do need a certain version to be loaded first, you can add it to the bootclasspath via
-Xbootclasspathparameter in the command line.库不包含方法，而类包含。当第一次需要类时，类由类加载器加载。
类（通常）按照类路径中出现的顺序加载。 通常只是因为奇特的自定义类加载器可以实现其他策略。
所以对于你的问题，看看正常行为：如果我们有两个类在路径上具有相同的名称，一个包含两个，另一个包含一个方法，那么只有一个类被加载，这是类加载器首先找到的类。一旦加载了一个类，（相同的）类加载器就不需要再次查找具有相同名称的类。
重载是在编译时静态确定的，因此方法 1 将（仍然）被调用。
A library does not contains methods, classes do. And classes are loaded by classloader when they are needed the first time.
Classes are (usually) loaded in the same order as they appear on the classpath. Usually just because fancy custom classloaders can implement other strategies.
So to your question, and looking at normal behaviour: If we have two classes with the same name on the path, one contains two, the other one method, then only one class is loaded, which is the one, that the classloaders finds first. Once a class is loaded, there's no need for (the same) classloader to look for a class with the same name again.
Overloading is determined statically at compile time, so method 1 will (still) be called.