Java: разрешение времени компиляции и наиболее конкретный метод применительно к переменной арности

1. int compute(String s1, Object... others) более конкретен, когда вы вызываете compute("hi",y,y), поскольку String является подклассом Object.

2. int compute(Object o1, Object o2, Object... others) является единственным совпадением для compute(y,y,y), потому что второй метод получает String в качестве первого параметра, а JLS15Test не является подклассом String

ИЗМЕНИТЬ

Мой ответ основан на основах конкретных методов, но ваш код компилируется только из-за способности компилятора различать методы описанным выше способом.

Следующие примеры даже не будут компилироваться из-за их неоднозначности:

Дело 1:

int compute(Object o1, Object o2, Object... others) { return 1; }
int compute(Object s1, Object... others)            { return 2; }

public static void main(String[] args) 
{
    JLS15Test y = new JLS15Test();
    System.out.println(y.compute(y,y,y));
    System.out.println(y.compute("hi",y,y));
}

случай 2:

int compute(String o1, Object o2, Object... others) { return 1; }
int compute(Object s1, String... others)            { return 2; }

public static void main(String[] args) 
{
    JLS15Test y = new JLS15Test();
    System.out.println(y.compute("hi","hi","hi"));
}

Еще редактировать

Первые два раза я плохо понял ваш вопрос (и надеюсь, что ответит на этот раз :)).

Фактический случай, о котором вы говорите, будет выглядеть так:

public class Test {
    public static void main(String[] args)
    {
        Test t = new Test();
        int a = t.compute("t", new Test());
        System.out.println(a);
    }

    int compute(String s, Object... others) { return 1; }
    int compute(Object s1, Object others)   { return 2; }
}

В этом случае compute(Object s1, Object others) действительно более конкретен, чем compute(String s, Object... others) (имеет меньше параметров), поэтому результат действительно будет 2.

Прочитав JLS несколько раз, я, наконец, думаю, что понял этот раздел.

Они говорят, что если есть два метода переменной арности, с целью решить, какой из них «более конкретный», вы можете рассмотреть тот, у которого более короткий список аргументов, как расширенный, чтобы он имел длину равную длине более длинному. . например

int compute(Object o1, Object o2, Object... others)
int compute(String s1, Object... others)

может рассматриваться (только в целях «более конкретного») как эквивалент

int compute(Object o1, Object o2, Object... others)
int compute(String s1, Object,    Object... others)

а затем типы аргументов сравниваются один за другим, причем последний метод является более конкретным.

(более строго, первый имеет n = 3, k = 2, n> = k, с String ‹: Object [String является подтипом Object], а JLS требует непосредственного сравнения типов каждого параметра для j между 1 и k-1 [на единицу меньше более короткой длины], сравнивая тип vararg более короткой сигнатуры метода с остальными параметрами более длинного метода.)

В следующем случае:

int compute(Object o1, Object o2, String... strings)
int compute(Object o1, String... strings)

они были бы эквивалентны (только в целях «более конкретного»)

int compute(Object o1, Object o2, String... strings)
int compute(Object o1, String,    String... strings)

и последнее более конкретное.

Таким образом, переменная арность никогда не превосходит подтипирование в целях сравнения «более конкретных» методов, которые имеют переменную арность.

Однако методы фиксированной арности всегда рассматриваются в первую очередь (JLS 15.12.2.2 и 15.12.2.3), а не методы переменной арности.

Второй вызов compute печатает 2, потому что во время компиляции известно, что литерал «hi» является String, поэтому компилятор выбирает вторую сигнатуру метода, потому что String более конкретен, чем Object.