14

这两天我有一个Java考试，我想不出这个问题的答案：

class ClassA {
 public String foo(Integer x , int y) {
  return "Integer, int";
 }
 public String foo(int x, Double y) {
  return "int, Double";
 }
 public String foo(Number x, Number y) {
  return "Number, Number";
 }
 public String foo(Object x, Object y) {
  return "Object, Object";
 }
 public static void main(String... args) {
  ClassA a = new ClassA();
  System.out.print(a.foo(5, 1.2f) + " ");
  System.out.println(a.foo(null, null));
 }
}

输出是什么？

答案是：

Number, Number Number, Number

我知道java总是选择最指定的方法，这就是为什么a.foo(null,null);会调用Number,Number方法而不是Object,Object方法。但是为什么a.foo(5,1.2f);还唤起Number,Number方法而不是int,Double方法？

但是还有一件事可能会有所帮助：如果我删除fafter 1.2，那么调用是： a.foo(5,1.2); 我收到编译器错误，它无法在Number,Numberandint,Double方法之间进行选择...

真的很有帮助，如果你们能向我解释一下:)

4

3 回答 3

18

1.2f不被 a 包裹Double，它被 a 包裹Float。由于Float不是 的子类Double（它们是 的不同子类Number），因此可以使用的最具体的方法签名是foo(Number,Number).

一旦你删除f， 1.2 将默认被视为 a double（原语，而不是包装类），它可以被自动装箱为 a Double。但是 5 也可以自动装箱为Integer，从而导致歧义。

于 2012-06-15T15:25:21.707 回答
4

这里有两个重要因素。

首先，1.2f不是一个Double。这是一个Float。(int, Double)功能完全不匹配。(Number, Number)是最合适的。

其次，即使您将其更改为1.2它仍然不是Double. 它是一个double. 也就是说，它是一个原始的，而不是一个对象。现在，Java 仍然会很乐意将 a 传递给double一个想要 a 的函数，Double而没有太多抱怨，但是在这种情况下，您通过给它可能进行的两次有效转换而混淆了它：

  1. 转换5为一个Integer 并转换1.2为一个Double
  2. 保留5为原始int但转换1.2为Double.

对于哪一个更可取，没有一个规则。Java 会产生一个编译器错误，它有一个模棱两可的函数调用，并迫使您选择您喜欢的那个（通过手动将它们中的一个或两个包装在对象中）。

顺便说一句，如果您有一个采用的方法，(int, double)则根本不会有歧义：该方法实际上与 and 的现有类型匹配5，1.2因此将调用它。事实上，这里的一些论点是导致混乱的包装对象。

于 2012-06-15T15:31:20.303 回答
1

通用答案：

public class OverloadingNumeric {

    public void print(int x){
        System.out.println("int");
    }

    public void print(long x){
        System.out.println("long");
    }

    public void print(float x){
        System.out.println("float");
    }

    public void print(double x){
        System.out.println("double");
    }

    public void print(Integer x){
        System.out.println("Integer");
    }

    public void print(Long x){
        System.out.println("Long");
    }

    public void print(Float x){
        System.out.println("Float");
    }

    public void print(Double x){
        System.out.println("Double");
    }

    public void print(Number x){
        System.out.println("Double");
    }

    public void print(Object x){
        System.out.println("Object");
    }

    public static void main(String[] args) {
        OverloadingNumeric obj = new OverloadingNumeric();
        /*
         * Primitives will take more precedence
         * of calling instead of wrapper class arguments,
         */
        obj.print(10);
        obj.print(10l);
        obj.print(10f);
        obj.print(10d);
        obj.print(10.1);
        //obj.print(999999999999999); Error: this letral type int is out of range
        obj.print(999999999999999l); 

        /*
         * OUTPUT
         * int
         * long
         * float
         * double
         * double
         * long
         */



        /*
         * Assume all primitive argument methods
         *  are commented. then calling the same again
         */
        obj.print(10);
        obj.print(10l);
        obj.print(10f);
        obj.print(10d);
        obj.print(10.1);

        //obj.print((Double)10); //Cannot cast int to Double 
        obj.print((double)10); //Success 
        //obj.print((Float)10); //Cannot cast int to Float 
        obj.print((float)10); //Success 
        //obj.print(null); ERROR AMBIGUOUS

        /*
         * OUTPUT
         * Integer
         * Long
         * Float
         * Double
         * Double
         * Double
         * Float
         * 
         */
    }
}




interface SuperIfc {}

class SuperClass implements SuperIfc{}

class SubClass extends SuperClass {}

public class OverloadingTest {

    public void print(SuperIfc x){
        System.out.println("SuperIfc");
    }

    public void print(SuperClass x){
        System.out.println("SuperClass");
    }

    public void print(SubClass x){
        System.out.println("SubClass");
    }

    public void print(Object x){
        System.out.println("Object");
    }

    public static void main(String[] args) {
        OverloadingTest obj = new OverloadingTest();
        SuperClass superObj = new SuperClass();
        SubClass subObj = new SubClass();
        obj.print(superObj);
        obj.print(subObj);
        obj.print(null);

        obj.print((SuperIfc)superObj);
        obj.print((SuperIfc)subObj);
        obj.print((SuperIfc)null);
        /*
         *  OUTPUT
         * SuperClass
         * SubClass
         * SubClass
         * SuperIfc
         * SuperIfc
         * SuperIfc
         */
    }
}
于 2014-05-30T06:42:15.517 回答