5

如果您尝试在下面使用重载函数compute1()compute2()和 ,则会导致编译错误:compute5()

package com.example.test.reflect;

class JLS15Test2
{
    int compute1(Object o1, Integer i, Integer j)         { return 1; }
    int compute1(String s1, Integer i, int j)             { return 2; }

    int compute2(Object o1, Integer i, int j)             { return 3; }
    int compute2(String s1, Integer i, Integer j)         { return 4; }

    int compute3(Object o1, Integer i, int j)             { return 5; }
    int compute3(String s1, Integer i, int j)             { return 6; }

    int compute4(Object o1, Integer i, Integer j)         { return 7; }
    int compute4(String s1, Integer i, Integer j)         { return 8; }

    int compute5(Object o1, Integer i, Object j)          { return 9; }
    int compute5(String s1, Integer i, int j)             { return 10; }


    public static void main(String[] args) 
    {
        JLS15Test2 y = new JLS15Test2();

        // won't compile:
        // The method compute1(Object, Integer, Integer) is ambiguous 
        // for the type JLS15Test2
        // System.out.println(y.compute1("hi", 1, 1));

        // Neither will this (same reason)
        // System.out.println(y.compute2("hi", 1, 1));
        System.out.println(y.compute3("hi", 1, 1));
        System.out.println(y.compute4("hi", 1, 1));

        // neither will this (same reason)
        // System.out.println(y.compute5("hi", 1, 1));
    }
}

在阅读了 JLS 第 15.12 节之后,我想我明白了......在匹配重载方法的第 2 阶段(允许装箱/拆箱,没有可变参数)中,在确定“最具体的方法”时,JLS 说(实际上)最特定方法是其形式参数是其他适用方法的子类型的方法,并且原语和对象(例如intInteger)绝不是彼此的子类型。SoInteger是 的子类型Integer,并且int是 的子类型int,但是Integer和与int/r/t 子类型比较不兼容,因此compute1()/compute2()对都没有最具体的方法。

(而 incompute3()compute4()带有String参数的方法比带有参数的方法更具体Object,所以程序打印 6 和 8。)

我的推理正确吗?

4

2 回答 2

0

是的,你的推理是正确的。

于 2011-05-19T17:13:48.627 回答
0

如果您添加另一个仅采用原始 int 和装箱 Integer 的方法,它能够解析哪个是正确调用的方法:

int compute6(int i) { return 11;}
int compute6(Integer i){return 12;}
...
System.out.println(y.compute6(1));

基于此,我想它与不同参数之间的交互有关,而不仅仅是单独的类型关系。

于 2011-05-19T17:15:00.627 回答