Why does autoboxing make some calls ambiguous in Java?

by

When you cast the first argument to Object yourself, the compiler will match the method without using autoboxing (JLS3 15.12.2):

The first phase (§15.12.2.2) performs
overload resolution without permitting
boxing or unboxing conversion, or the
use of variable arity method
invocation. If no applicable method is
found during this phase then
processing continues to the second
phase.

If you don’t cast it explicitly, it will go to the second phase of trying to find a matching method, allowing autoboxing, and then it is indeed ambiguous, because your second argument can be matched by boolean or Object.

The second phase (§15.12.2.3) performs
overload resolution while allowing
boxing and unboxing, but still
precludes the use of variable arity
method invocation.

Why, in the second phase, doesn’t the compiler choose the second method because no autoboxing of the boolean argument is necessary? Because after it has found the two matching methods, only subtype conversion is used to determine the most specific method of the two, regardless of any boxing or unboxing that took place to match them in the first place (§15.12.2.5).

Also: the compiler can’t always choose the most specific method based on the number of auto(un)boxing needed. It can still result in ambiguous cases. For example, this is still ambiguous:

public class Test {
    static void f(Object a, boolean b) {}
    static void f(int a, Object b) {}

    static void m(int a, boolean b) { f(a, b); } // ambiguous
}

Remember that the algorithm for choosing a matching method (compile-time step 2) is fixed and described in the JLS. Once in phase 2 there is no selective autoboxing or unboxing. The compiler will locate all the methods that are accessible (both methods in these cases) and applicable (again the two methods), and only then chooses the most specific one without looking at boxing/unboxing, which is ambiguous here.

More Related Contents:

  1. Why doesn’t autoboxing overrule varargs when using method overloading in Java 7?
  2. foo(int) is not applicable for the arguments (String)
  3. How can I properly compare two Integers in Java?
  4. Polymorphism vs Overriding vs Overloading
  5. How to convert int[] into List in Java?
  6. How to create AST with ANTLR4?
  7. How does auto boxing/unboxing work in Java?
  8. What is the difference between dynamic and static polymorphism in Java?
  9. Why does int num = Integer.getInteger(“123”) throw NullPointerException?
  10. Java – why no return type based method overloading?
  11. Method overload resolution in java
  12. Why aren’t Integers cached in Java?
  13. Java Arrays.asList on primitive array type produces unexpected List type [duplicate]
  14. Why does Java switch on contiguous ints appear to run faster with added cases?
  15. Does concatenating strings in Java always lead to new strings being created in memory?
  16. Compiling multiple packages using the command line in Java
  17. Unreachable code compiler error [duplicate]
  18. Java method overloading + double dispatch
  19. Eclipse: enable assertions
  20. Java overloading and overriding
  21. Why does type-promotion take precedence over varargs for overloaded methods
  22. How to do method overloading for null argument?
  23. How can I create a Java method that accepts a variable number of arguments?
  24. On-the-fly, in-memory java code compilation for Java 5 and Java 6
  25. Varargs in method overloading in Java
  26. How to emit and execute Java bytecode at runtime?
  27. default maven compiler setting
  28. Meaning of Android Studio error: Not annotated parameter overrides @NonNull parameter
  29. java : Understanding Arrays.asList(T…array) method for primitive types
  30. Does Java autobox when assigning an int to an Object?

Leave a Comment