Java：编译时解析和“最具体的方法”，因为它适用于变量数量

有人可以帮助我理解吗JLS re：最具体方法的第 15.12.2.5 节?

（以下是来自 JLS 的猛击剪切和粘贴）

此外，如果满足以下任一条件，则一个名为 m 的变量 arity 成员方法比另一个同名的变量 arity 成员方法更具体：

• 一个成员方法有 n 个参数，另一个有 k 个参数，其中 n >= k。第一个成员方法的参数类型为T1,...。 。 。 , Tn-1 , Tn[],另一个方法的参数类型为U1, . 。 。 ，Uk-1，Uk[]。如果第二种方法是泛型的，则令 R1 ... Rp p1 为其形式类型参数，令 Bl 为 Rl、1lp 的声明边界，令 A1 ... Ap 为推断的实际类型参数（第 15.12.2.7 节）对于此调用，在初始约束 Ti
• 一个成员方法有 k 个参数，另一个有 n 个参数，其中 n >= k。第一个方法的参数类型为U1,. 。 。 ，Uk-1，Uk[]，另一个方法的参数类型为T1，. 。 ., Tn-1, Tn[]。如果第二种方法是泛型的，则令 R1 ... Rp p1 为其形式类型参数，令 Bl 为 Rl、1lp 的声明边界，令 A1 ... Ap 为推断的实际类型参数（第 15.12.2.7 节）对于此调用，在初始约束下 Ui

忽略泛型问题，这是否意味着在确定一种方法是否比另一种方法更具体时，可变参数比子类型更重要，或者子类型比可变参数更重要？我想不通。

具体例子：下列哪一项compute()根据 JLS，方法“更具体”？

package com.example.test.reflect;

class JLS15Test
{
    int compute(Object o1, Object o2, Object... others) { return 1; }
    int compute(String 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));
    }
}

我不知道哪个是“更具体”；输出打印

1
2

我很困惑如何解释结果。当第一个参数是字符串时，编译器会选择具有更具体子类型的方法。当第一个参数是对象时，编译器会选择可选可变参数数量较少的方法。

NOTE：如果您没有阅读 JLS 的这一部分，并且您给出的答案取决于论点，你没有帮我。如果你仔细阅读JLS，除了与泛型相关的部分之外，“更具体”的定义取决于声明的参数，而不是实际的参数-- 这在 JLS 的其他部分发挥作用（目前找不到）。

例如对于固定数量方法，compute(String s)会比更具体compute(Object o)。但我试图了解 JLS re: 变量数量方法的相关部分。

1. int compute(String s1, Object... others)当你打电话时会更具体compute("hi",y,y), since String是对象的子类。

2. int compute(Object o1, Object o2, Object... others) is the only匹配compute(y,y,y)因为第二个方法接收 String 作为第一个参数，并且JLS15Test不是 的子类String

EDIT

我的答案基于特定方法的基础知识，但您的代码只能编译，因为编译器能够以上述方式区分方法。

由于含糊不清，以下示例甚至无法编译：

case 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));
}

case 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 indeed.