Java: compile-time resolution and "most specific method"

Question

The overloaded functions compute1(), compute2(), and compute5() cause compilation errors if you try to use them below:

package com.example.test.reflect;

class JLS15Test2
{
    int compute1(Object o1, Integer i, Integer j)         { return 1; }
    int compute1(String s1, Integer i, int j)             { return 2; }

    int compute2(Object o1, Integer i, int j)             { return 3; }
    int compute2(String s1, Integer i, Integer j)         { return 4; }

    int compute3(Object o1, Integer i, int j)             { return 5; }
    int compute3(String s1, Integer i, int j)             { return 6; }

    int compute4(Object o1, Integer i, Integer j)         { return 7; }
    int compute4(String s1, Integer i, Integer j)         { return 8; }

    int compute5(Object o1, Integer i, Object j)          { return 9; }
    int compute5(String s1, Integer i, int j)             { return 10; }


    public static void main(String[] args) 
    {
        JLS15Test2 y = new JLS15Test2();

        // won't compile:
        // The method compute1(Object, Integer, Integer) is ambiguous 
        // for the type JLS15Test2
        // System.out.println(y.compute1("hi", 1, 1));

        // Neither will this (same reason)
        // System.out.println(y.compute2("hi", 1, 1));
        System.out.println(y.compute3("hi", 1, 1));
        System.out.println(y.compute4("hi", 1, 1));

        // neither will this (same reason)
        // System.out.println(y.compute5("hi", 1, 1));
    }
}

After reading the JLS section 15.12, I think I understand... in phase 2 (boxing/unboxing allowed, no varargs) of matching overloaded methods, when determining the "most specific method", the JLS says (in effect) that the most specific method is the one whose formal parameters are subtypes of other applicable methods, and primitives and Objects (e.g. int and Integer) are never subtypes of each other. So Integer is a subtype of Integer, and int is a subtype of int, but Integer and int are incompatible w/r/t subtype comparisons, so neither of the compute1()/compute2() pairs have a most specific method.

(Whereas in compute3() and compute4() the method with the String argument is more specific than the method with the Object argument, so the program prints 6 and 8.)

Is my reasoning correct?

Answer 1

Yes, your reasoning is correct.