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

Question

有人可以帮助我理解 第 15.12.2.5 节JLS回复：最具体的方法？

（以下是来自 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 << 下的此调用Ui，1ik-1，Ti＜＜ Uk, kin 并设 Si = Ui[R1 = A1, ..., Rp = Ap] 1ik；否则令 Si = Ui, 1ik。然后： 对于从 1 到 k-1 的所有 j，Tj <：Sj，并且， 对于从 k 到 n 的所有 j，Tj <：Sk，并且， 如果第二方法是如上所述的通用方法，则A1＜：Bl[R1＝A1，...，Rp＝Ap]，1lp。
• 一个成员方法有 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 << Ti，1ik-1，Uk＜＜ Ti, kin 并设 Si = Ti[R1 = A1, ..., Rp = Ap] 1in；否则令 Si = Ti, 1in。然后： 对于从 1 到 k-1 的所有 j，Uj <：Sj，并且， 对于从 k 到 n 的所有 j ，Uk <：Sj，并且， 如果第二方法是如上所述的通用方法，则A1＜：Bl[R1＝A1，...，Rp＝Ap]，1lp。

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

具体示例：根据 JLS，以下哪个 compute() 方法“更具体”？

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

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

---

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

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

Answer 1

1. 当您调用compute("hi",y,y)时，

   intcompute(String s1, Object...others)更加具体，因为String 是 Object 的子类。

2. intcompute(Object o1, Object o2, Object...others) 是 compute(y,y,y)唯一匹配项code> 因为第二个方法接收 String 作为第一个参数，并且 JLS15Test 不是 String

编辑

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

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

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 other) 确实比compute(String s, Object... other) 更具体 （参数较少），因此输出实际上是 2 。

Answer 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 [比较短的长度少一]，将较短方法签名的可变参数类型与较长方法的其余参数进行比较。）

在以下情况下：

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）。

Answer 3

第二个计算调用打印 2，因为在编译时已知文字“hi”是一个 String，因此编译器选择第二个方法签名，因为 String 比 Object 更具体。