java - C# 和 Java 中的方法重载

Question

我在 C# 中运行了以下方法。

public float Add(float num1, long num2)
{
    Console.WriteLine("method 1");
    return 0;
}
public float Add(int num1, float num2)
{
    Console.WriteLine("method 2");
    return 0;
}

在这里，如果我调用 Add(1,1)，它会产生歧义。现在让我交换第一种方法中 float 和 long 的位置，如下所示:

public float Add(long num1, float num2)
{
    Console.WriteLine("method 1");
    return 0;
}
public float Add(int num1, float num2)
{
    Console.WriteLine("method 2");
    return 0;
}

现在它打印“方法 2”作为输出。第一种情况的歧义背后的原因是什么？

如果我在代码中编写以下两个方法:

public float Add(long num1, long num2)
{
    Console.WriteLine("method 1"); 
    return 0;
}
public float Add(int num1, float num2)
{
    Console.WriteLine("method 2");
    return 0;
}

在调用 Add(1,1) 时，会出现歧义错误。为什么它不进行最佳匹配，这是第二种方法(具有 int 和 float)？根据我的说法，它应该给出方法 2 作为输出。

Answer 1

来自C# specification , 7.5.3.2 Better Function 成员:

Given an argument list A with a set of argument expressions { E1, E2, ..., EN } and two applicable function members MP and MQ with parameter types { P1, P2, ..., PN } and { Q1, Q2, ..., QN }, MP is defined to be a better function member than MQ if

• for each argument, the implicit conversion from EX to QX is not better than the implicit conversion from EX to PX, and
• for at least one argument, the conversion from EX to PX is better than the conversion from EX to QX.

请注意，规范以包含身份转换的方式使用术语隐式转换。请参阅 6.1 隐式转换:

The following conversions are classified as implicit conversions:

• Identity conversions
• Implicit numeric conversions
• [...]

并且来自 6.1.1 身份转换:

An identity conversion converts from any type to the same type. [...]

---

您的参数类型集是:

{ int, int }

---

在第一种情况下，候选人是:

{ float, long } 
{ int, float }

设MP为第一候选，MQ为第二候选。

• 有一个参数 X (= 1)，其中从 EX 到 QX 的隐式转换优于从 EX 到 PX 的隐式转换:int 到 int 优于 int 到 float(因为它们是同一类型)。

设MP为第二候选，MQ为第一候选。

• 有一个参数 X (= 2)，其中从 EX 到 QX 的隐式转换优于从 EX 到 PX 的隐式转换:int 到 long 在 float 方面优于 int。

两位候选人都不满足第一个要点。规范中描述的打破平局的机制在这里不适用(因为这两种方法都不是通用的，也不是可变的，也没有可选参数，等等)。因此，这个调用是不明确的。

---

在第二种情况下，候选人是:

{ long, float }
{ int, float }

设MP为第一候选，MQ为第二候选。

• 有一个参数 X (= 1)，其中从 EX 到 QX 的隐式转换优于从 EX 到 PX 的隐式转换:int 到 int 优于 int 到 long(因为它们是同一类型)。

设MP为第二候选，MQ为第一候选。

• 没有参数 X，其中从 EX 到 QX 的隐式转换优于从 EX 到 PX 的隐式转换。
• 有一个参数 X (= 1)，其中从 EX 到 PX 的隐式转换优于从 EX 到 QX 的转换:int 到 int 优于 int 到 long。

由于第二个候选人同时满足两个要点，因此它比第一个更好。

---

第三种情况，候选人是:

{ long, long }
{ int, float } 

就像第一种情况:

• int 到 int 优于 int 到 long。
• 但是 int 到 long 比 int 到 float 更好。

因此，这个调用又是模棱两可的。

---

Java Language Specification 15.12.2.5 选择最具体的方法中指出:

One applicable method m1 is more specific than another applicable method m2, for an invocation with argument expressions e1, ..., ek, if any of the following are true:

• m2 is generic, and m1 is inferred to be more specific than m2 for argument expressions e1, ..., ek by §18.5.4.
• m2 is not generic, and m1 and m2 are applicable by strict or loose invocation, and where m1 has formal parameter types S1, ..., Sn and m2 has formal parameter types T1, ..., Tn, the type Si is more specific than Ti for argument ei for all i (1 ≤ i ≤ n, n = k).
• m2 is not generic, and m1 and m2 are applicable by variable arity invocation, and where the first k variable arity parameter types of m1 are S1, ..., Sk and the first k variable arity parameter types of m2 are T1, ..., Tk, the type Si is more specific than Ti for argument ei for all i (1 ≤i≤k). Additionally, if m2 has k+1 parameters, then the k+1'th variable arity parameter type of m1 is a subtype of the k+1'th variable arity parameter type of m2.

The above conditions are the only circumstances under which one method may be more specific than another.

A type S is more specific than a type T for any expression if S <: T (§4.10).

和以前一样，请注意这里描述的关系包括 S 和 T 是同一类型的情况，而不是彼此的严格子类型(这将是正确的子类型)。

对于基本类型，在4.10.1 基本类型之间的子类型化中有描述:

The following rules define the direct supertype relation among the primitive types:

• double >1 float
• float >1 long
• long >1 int
• int >1 char
• int >1 short
• short >1 byte

有了这些，对于这种特殊情况，重载决议规则实际上与 C# 相同。前面的解释是适用的。