C# 和 Java 中的方法重载

我在 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 and 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 and float）？根据我的说法，它应该给出方法 2 作为输出。

来自C#规范 https://msdn.microsoft.com/en-us/library/ms228593.aspx, 7.5.3.2 更好功能成员:

给定一个参数列表 A，其中包含一组参数表达式 { E1, E2, ..., EN } 和两个适用的函数成员 MP 和 MQ，其参数类型为 { P1, P2, ..., PN } 和 { Q1, Q2， ..., QN }, MP 被定义为比 MQ 更好的函数成员，如果

• 对于每个参数，从 EX 到 QX 的隐式转换并不比从 EX 到 PX 的隐式转换更好，并且
• 对于至少一个参数，从 EX 到 PX 的转换优于从 EX 到 QX 的转换。

请注意，该规范使用术语隐式转换以包括身份转换的方式。看6.1 隐式转换:

以下转换被归类为隐式转换：

• 身份转换
• 隐式数值转换
• [...]

并从6.1.1 身份转换:

身份转换从任何类型转换为相同类型。 [...]

您的参数类型集是：

{ int, int }

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

{ float, long } 
{ int, float }

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

• 有一个参数 X (= 1)，其中从 EX 到 QX 的隐式转换is比从 EX 到 PX 的隐式转换更好：int to int比int to float（因为它是同一类型）。

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

• 有一个参数 X (= 2)，其中从 EX 到 QX 的隐式转换is比从 EX 到 PX 的隐式转换更好：int to long比int to float.

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

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

{ long, float }
{ int, float }

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

• 有一个参数 X (= 1)，其中从 EX 到 QX 的隐式转换is比从 EX 到 PX 的隐式转换更好：int to int比int to long（因为它是同一类型）。

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

• 没有参数 X 表明从 EX 到 QX 的隐式转换优于从 EX 到 PX 的隐式转换。
• 有一个参数 X (= 1)，其中从 EX 到 PX 的隐式转换is比从 EX 到 QX 的转换更好：int to int比int to long.

由于第二个候选者满足这两个要点，因此它比第一个候选者更匹配。

在第三种情况下，候选人是：

{ long, long }
{ int, float } 

就像第一种情况一样：

• int to int比int to long.
• But int to long比int to float.

因此，该调用再次变得不明确。

The Java语言规范 https://docs.oracle.com/javase/specs/各州15.12.2.5 选择最具体的方法:

对于使用参数表达式 e1, ..., ek 的调用，如果满足以下任一条件，则一个适用的方法 m1 比另一适用的方法 m2 更具体：

• m2 是通用的，并且根据第 18.5.4 节，对于参数表达式 e1, ..., ek，m1 被推断为比 m2 更具体。
• m2 不是泛型，m1 和 m2 可通过严格或松散调用应用，其中 m1 具有形式参数类型 S1, ..., Sn，m2 具有形式参数类型 T1, ..., Tn，类型 Si 更重要对于所有 i (1 ≤ i ≤ n, n = k)，参数 ei 比 Ti 更具体。
• m2 不是通用的，m1 和 m2 可通过变量参数调用来应用，其中 m1 的前 k 个变量参数类型为 S1, ..., Sk，m2 的前 k 个变量参数类型为 T1, ... ., Tk，对于所有 i (1 ≤ i ≤ k) 的参数 ei，类型 Si 比 Ti 更具体。另外，如果m2具有k+1个参数，则m1的第k+1个可变数量参数类型是m2的第k+1个可变数量参数类型的子类型。

上述条件是一种方法可能比另一种方法更具体的唯一情况。

对于任何表达式，如果 S <: t s>

与之前一样，请注意，此处描述的关系包括 S 和 T 是同一类型的情况，而不是严格意义上的彼此子类型（这将是正确的子类型).

对于原始类型，描述于4.10.1 原始类型之间的子类型化:

以下规则定义了原始类型之间的直接超类型关系：

• 双 >1 浮点数
• 浮动 >1 长
• 长 > 1 个整数
• 整数 >1 个字符
• 整数 >1 短
• 短 >1 字节

通过这些，重载解析规则实际上与此特定情况下的 C# 相同。前面的解释是适用的。