blocks|key|858753|text|如果您喜欢引人入胜的阅读，以下是Java语言规范的相关部分，它描述了如何解决方法。|type|unstyled|depth|inlineStyleRanges|entityRanges|offset|length|data|858754|但基本上，您的第三个参数可以解释为原语或自动装箱包装器，编译器无法确定您想要什么。这两种方法在使用JLS术语时都是“最大特定的”。|858755|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12^0|D|G|0|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@]|9|@$A|O|B|P|1|Q]]|C|$]]|$1|D|3|E|5|6|7|R|8|@]|9|@]|C|$]]|$1|F|3|-4|5|6|7|S|8|@]|9|@]|C|$]]]|G|$H|$5|I|J|K|C|$L|M]]]]

If you enjoy riveting reading, <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12" rel="noreferrer">here is the relevant portion of the Java Language specification</a> that describes how methods are resolved.

But basically your third argument can be interpreted as a primitive or an autoboxed wrapper, and the compiler can't figure out what you want. Both methods are "maximally specific" to use the JLS terminology.

blocks|key|387176|text|您的第二个参数2004+(即int+)也适用于Integer，因为自动拳击，这就是编译器无法决定使用哪种方法的原因。|type|unstyled|depth|inlineStyleRanges|offset|length|style|CODE|entityRanges|data|387177|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/tutorial/java/data/autoboxing.html^0|7|4|E|3|N|7|X|4|0|0^^$0|@$1|2|3|4|5|6|7|N|8|@$9|O|A|P|B|C]|$9|Q|A|R|B|C]|$9|S|A|T|B|C]]|D|@$9|U|A|V|1|W]]|E|$]]|$1|F|3|-4|5|6|7|X|8|@]|D|@]|E|$]]]|G|$H|$5|I|J|K|E|$L|M]]]]

Your second argument <code>2004</code> which is an <code>int</code> would also apply to an <code>Integer</code> because of <a href="http://docs.oracle.com/javase/tutorial/java/data/autoboxing.html" rel="nofollow">auto-boxing</a>, thats why the compiler can't decide which method to use.

blocks|key|2558508|text|好的，我已经仔细观察了JLS，我相信这应该可以消除你可能还有的疑问。|type|unstyled|depth|inlineStyleRanges|entityRanges|data|2558509|这就是最初的问题：|2558510|public+class+Main+{
++++private+static+void+flipFlop(int+i,+Integer+iRef)+{
++++++++System.out.println("Method+1");
++++}

++++private+static+void+flipFlop(int+i,+int+j)+{
++++++++System.out.println("Method+2");
++++}

++++public+static+void+main(String[]+args)+{
++++++++flipFlop(new+Integer(4),+2004);
++++}
}|code-block|syntax|javascript|2558511|正如在另一个答案中所指出的:这失败了，因为编译器无法决定使用什么重载。|2558512|然而，你可能认为这没有任何意义。在这种情况下，编译器可以很好地决定应该使用什么方法：|2558513|public+class+Main+{
++++private+static+void+flipFlop(Integer+y)+{
++++++++System.out.println("ciao");
++++}

++++private+static+void+flipFlop(int+j)+{
++++++++System.out.println("hello");
++++}

++++public+static+void+main(String[]+args)+{
++++++++flipFlop(new+Integer(6));
++++++++flipFlop(6);
++++}
}|2558514|理性告诉我们，当你有值X+%2B+Y和分别采用Y+%2B+X和Y+%2B+Y的两种方法时，你知道X和Y是可互换的，这意味着后一种方法更具体。|offset|length|style|CODE|2558515|JLS描述了这两者之间的差异。我提供了以下的整个工作流程，但重要的是：|2558516|首先，编译器将查看具有相同签名的方法，而则禁止装箱/取消装箱。在我们的第二个例子中，这不会引起任何问题，但是在我们的第一个示例中，这不会返回一个可满足的方法，因为它们都不接受Integer作为第一个参数。|BOLD|2558517|如果失败，编译器将转到第二步，在该步骤中，允许装箱/取消装箱。这应该解决了第一个参数的问题，但现在导致了第二个参数的模糊性，因为现在还不清楚您是指使用int的重载还是使用Integer的重载。|2558518|这最终导致一个不明确的方法调用。|2558519|15.12.2编译时步骤2:确定方法签名|2558520|blockquote|2558521|第一阶段(第15.12.2.2节)执行重载解析，而不允许装箱或取消装箱转换，也不允许使用可变的方法调用。如果在此阶段没有找到适用的方法，则处理将继续到第二阶段。|ordered-list-item|2558522|第二阶段(第15.12.2.3节)在允许装箱和取消装箱的同时执行重载解析，但仍然排除了变量方法调用的使用。如果在此阶段没有找到适用的方法，则处理将继续到第三阶段。|2558523|如果在适用性测试的三个阶段中的一个阶段已经确定了几种适用的方法，那么就选择最具体的方法，如§15.12.2.5节所规定的那样。|2558524|15.12.2.5选择最具体的方法|2558525|如果方法是可访问和可应用的，并且没有其他可应用和可访问的方法，则该方法对于方法调用来说是最大的特定的。
可能没有任何方法是最具体的，因为有两个或更多的方法具有最大的特定性。在这种情况下：|2558526|如果所有最大特定的方法都有覆盖等效(§8.4.2)签名，那么：(.(决定谁被选中的一些规则。)|unordered-list-item|2558527|否则，我们会说方法调用是不明确的，并且会发生编译时错误.|2558528|entityMap|0|LINK|mutability|MUTABLE|url|http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2|1|http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.2|2|http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.3|3|http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.5|4|5|http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.2^0|0|0|0|0|0|0|B|1|F|1|L|1|P|1|R|1|V|1|16|1|18|1|0|0|K|3|2F|7|0|L|2|23|3|2D|7|0|0|0|K|0|0|0|N|E|5|B|1|0|10|19|5|B|2|0|0|1R|19|A|3|0|0|H|0|H|4|0|0|1F|1G|15|0|0|1B|I|6|5|0|0|S|0^^$0|@$1|2|3|4|5|6|7|24|8|@]|9|@]|A|$]]|$1|B|3|C|5|6|7|25|8|@]|9|@]|A|$]]|$1|D|3|E|5|F|7|26|8|@]|9|@]|A|$G|H]]|$1|I|3|J|5|6|7|27|8|@]|9|@]|A|$]]|$1|K|3|L|5|6|7|28|8|@]|9|@]|A|$]]|$1|M|3|N|5|F|7|29|8|@]|9|@]|A|$G|H]]|$1|O|3|P|5|6|7|2A|8|@$Q|2B|R|2C|S|T]|$Q|2D|R|2E|S|T]|$Q|2F|R|2G|S|T]|$Q|2H|R|2I|S|T]|$Q|2J|R|2K|S|T]|$Q|2L|R|2M|S|T]|$Q|2N|R|2O|S|T]|$Q|2P|R|2Q|S|T]]|9|@]|A|$]]|$1|U|3|V|5|6|7|2R|8|@]|9|@]|A|$]]|$1|W|3|X|5|6|7|2S|8|@$Q|2T|R|2U|S|Y]|$Q|2V|R|2W|S|T]]|9|@]|A|$]]|$1|Z|3|10|5|6|7|2X|8|@$Q|2Y|R|2Z|S|Y]|$Q|30|R|31|S|T]|$Q|32|R|33|S|T]]|9|@]|A|$]]|$1|11|3|12|5|6|7|34|8|@]|9|@]|A|$]]|$1|13|3|14|5|6|7|35|8|@]|9|@$Q|36|R|37|1|38]]|A|$]]|$1|15|3|-4|5|16|7|39|8|@]|9|@]|A|$]]|$1|17|3|18|5|19|7|3A|8|@$Q|3B|R|3C|S|Y]]|9|@$Q|3D|R|3E|1|3F]]|A|$]]|$1|1A|3|1B|5|19|7|3G|8|@$Q|3H|R|3I|S|Y]]|9|@$Q|3J|R|3K|1|3L]]|A|$]]|$1|1C|3|1D|5|6|7|3M|8|@$Q|3N|R|3O|S|Y]]|9|@$Q|3P|R|3Q|1|3R]]|A|$]]|$1|1E|3|1F|5|6|7|3S|8|@$Q|3T|R|3U|S|Y]]|9|@$Q|3V|R|3W|1|3X]]|A|$]]|$1|1G|3|1H|5|16|7|3Y|8|@$Q|3Z|R|40|S|Y]|$Q|41|R|42|S|Y]]|9|@]|A|$]]|$1|1I|3|1J|5|1K|7|43|8|@$Q|44|R|45|S|Y]]|9|@$Q|46|R|47|1|48]]|A|$]]|$1|1L|3|1M|5|1K|7|49|8|@$Q|4A|R|4B|S|Y]]|9|@]|A|$]]|$1|1N|3|-4|5|6|7|4C|8|@]|9|@]|A|$]]]|1O|$1P|$5|1Q|1R|1S|A|$1T|1U]]|1V|$5|1Q|1R|1S|A|$1T|1W]]|1X|$5|1Q|1R|1S|A|$1T|1Y]]|1Z|$5|1Q|1R|1S|A|$1T|20]]|21|$5|1Q|1R|1S|A|$1T|20]]|22|$5|1Q|1R|1S|A|$1T|23]]]]

Alright, I have taken a closer look at the JLS and I believe this should clear up any remaining doubts you might have.
This is the original problem:
<pre><code>public class Main {
 private static void flipFlop(int i, Integer iRef) {
 System.out.println(&quot;Method 1&quot;);
 }

 private static void flipFlop(int i, int j) {
 System.out.println(&quot;Method 2&quot;);
 }

 public static void main(String[] args) {
 flipFlop(new Integer(4), 2004);
 }
}
</code></pre>
As has been pointed out in the other answer: this fails because the compiler can't decide what overload to use.
However you might think this doesn't make any sense. The compiler can decide just fine in this situation what method he should use:
<pre><code>public class Main {
 private static void flipFlop(Integer y) {
 System.out.println(&quot;ciao&quot;);
 }

 private static void flipFlop(int j) {
 System.out.println(&quot;hello&quot;);
 }

 public static void main(String[] args) {
 flipFlop(new Integer(6));
 flipFlop(6);
 }
}
</code></pre>
Rationality tells us that when you have values <code>X</code> + <code>Y</code> and two methods that take respectively <code>Y</code> + <code>X</code> and <code>Y</code> + <code>Y</code> and you know that <code>X</code> and <code>Y</code> are interchangeable, then this would mean that the latter method is more specific.
The difference between these two are described in the JLS. I have provided the entire workflow below, but what matters is this:
First the compiler will look at methods with an equal signature while forbidding boxing/unboxing. In our second example this doesn't cause any problems, but in our first example this doesn't return a satisfiable method since neither of them take an <code>Integer</code> as the first parameter..
When that failed, the compiler moves on to the second step where it allows boxing/unboxing. This should fix the issue we had with the first parameter, but now causes ambiguity with the second parameter since it is now uncertain whether you're referring to the overload using an <code>int</code> or the one using an <code>Integer</code>.
This ultimately results in an ambiguous method call.
<a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2" rel="noreferrer">15.12.2. Compile-Time Step 2: Determine Method Signature</a>
<blockquote>
<ol>
<li>The first phase (<a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.2" rel="noreferrer">§15.12.2.2</a>) performs overload resolution without permitting boxing or unboxing conversion, or the use of variable arity method invocation. If no applicable method is found during this phase then processing continues to the second phase.
</li>
<li>The second phase (<a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.3" rel="noreferrer">§15.12.2.3</a>) performs overload resolution while allowing boxing and unboxing, but still precludes the use of variable arity method invocation. If no applicable method is found during this phase then processing continues to the third phase.
</li>
</ol>
If several applicable methods have been identified during one of the three phases of applicability testing, then the most specific one is chosen, as specified in section <a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.5" rel="noreferrer">§15.12.2.5</a>.
</blockquote>
<a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-15.html#jls-15.12.2.5" rel="noreferrer">15.12.2.5. Choosing the Most Specific Method</a>
<blockquote>
A method is said to be maximally specific for a method invocation if it is accessible and applicable and there is no other method that is applicable and accessible that is strictly more specific.
It is possible that no method is the most specific, because there are two or more methods that are maximally specific. In this case:
<ul>
<li>If all the maximally specific methods have override-equivalent (<a href="http://docs.oracle.com/javase/specs/jls/se7/html/jls-8.html#jls-8.4.2" rel="noreferrer">§8.4.2</a>) signatures, then: (... some rules to decide who's chosen ...)
</li>
<li>Otherwise, we say that the method invocation is ambiguous, and a compile-time error occurs.
</li>
</ul>
</blockquote>

It's just an exercise but I can't figure out the ambiguity:

<pre><code>private static void flipFlop(String str, int i, Integer iRef) {
System.out.println(str + "ciao");
}

private static void flipFlop(String str, int i, int j) {
System.out.println(str + "hello");
}

public static void main(String[] args) {
flipFlop("hello", new Integer(4), 2004);
}
</code></pre>

It says: 

<blockquote>
 The method flipFlop(String, int, Integer) is ambiguous for the type
 Test
</blockquote>

I would have guessed that the second argument would have been unwrapped to int and so the second <code>flipFlop</code> method would have been the choice.

Why do two methods with signature (primitive, wrapper) and (primitive, primitive) cause the method call (wrapper, primitive) to be ambiguous?

翻译质量差，导致语言生硬或混乱。

没有提供实际的解决方法或示例。

解答不清晰，无法理解或解决问题。

页面排版不美观，阅读体验差。

文章

问答

视频

学习中心

腾讯云实验室

直播

竞赛

腾讯云代码分析专区

腾讯iOA零信任安全管理系统专区

腾讯云架构师技术同盟交流圈

腾讯云数据库专区

腾讯云顾问专区

腾讯云原生专区

腾讯混元专区

腾讯云TCE专区

腾讯云Lighthouse专区

腾讯云HAI专区

腾讯云Edgeone专区

腾讯云存储专区

腾讯云智能专区

腾讯轻联专区 

腾讯云开发专区

TAPD专区

腾讯轻量云游戏服专区

腾讯云最具价值专家

腾讯云架构师技术同盟

腾讯云创作之星

腾讯云开发者先锋

腾讯云代码助手

云原生构建

TAPD 敏捷项目管理

Cloud Studio

SDK中心

API中心

命令行工具

涵盖代码开发、场景应用、自动测试全流程，助你从零构建专属AI助手

一站式MCP教程库，解锁AI应用新玩法

这只是一个练习，但我搞不懂模棱两可的地方：private static void flipFlop(String str, int i, Integer iRef) {System.out.println(str + "ciao");}private static void flipFlop(String str, i...

问为什么有签名的两个方法(原语，包装器)和(原语，原语)会导致方法调用(包装器，原语)模棱两可？
EN

Stack Overflow用户

社区

活动

圈层

关于

腾讯云开发者

热门产品

热门推荐

更多推荐

问为什么有签名的两个方法(原语，包装器)和(原语，原语)会导致方法调用(包装器，原语)模棱两可？EN