大家看看这个简单的程序输出结果?

Question

public class test{
       public void t(Object x){
              System.out.println("Object");
              }
      
       public void t(String x){
              System.out.println("String");
              }
          
       public static void main(String[] args){
              test tt = new test();
                   tt.t(null);
              }
       }说出输出结果? 最重要的是为什么?

Answer 1

输出String，应该是多态问题吧，
null是String，String是Object，null是Object，根据thinking in java上的说法应该是动态绑定，所以调用参数为String的函数
不知道这样解释对不对

Answer 2

不是动态绑定. 只是overloading(编译期决定函数)

Answer 3

java中对于重载(Overloaded)方法的选择是静态的,而对于被改写的(Overridden)的方法的选择是动态的!
 
应该在程序设计中避免使用这种重载方法.你可以去看一下effective java的第26条.

Answer 4

public class ClassTest {

Object tt;
public ClassTest (){

}

public void doTest(Object myobject){
tt = myobject;
tt.getClass().getMethods();
}

public void doTest(String myobject){
tt = myobject;
tt.getClass().getMethods();
}

public static void main(String[] src){
ClassTest test = new ClassTest();
test.doTest(null);
}
}当test.doTest("我到底爱谁");
DeBug跳入 public void doTest(String myobject)当test.doTest(null);
DeBug跳入 public void doTest(String myobject)当test.doTest(new ArrayList());
DeBug跳入 public void doTest(Object myobject)

Answer 5

Object 与String 都是对象 null 做为参数到底应该执行那个方法,为什么?

Answer 6

由于重载是静态联编的，对于一般的变量，声明的变量是什么，就会自动载入相应的函数，而不考虑变量实际是否其实是个子类的向上转型，从而载入更适合的以子类为参数的函数。因为在编译期间，系统并不知道这个变量具体的类型。
  但是对于null来说，在编译期间，系统就知道它是一个string,也是一个object。所以系统自然选择更适合的string为参数的函数。同理如果两个函数，一个是object,一个是int[],系统也是选择作为子类的int[]为参数的函数。
  如果碰到一个String,一个int[]重载的情况，系统就会报参数混淆的错误。因为string heddd

Answer 7

我倒，出错了，为了不重新打字，所以发出来了，现在续上
 
   如果碰到一个String,一个int[]重载的情况，系统就会报参数混淆的错误。因为string 和int[]不存在继承关系，所以说系统找不到更贴切的参数类型，所以无法分清究竟访问的哪个函数，所以会报错。
测试用的代码如下
public class TestNull {

void f(int[] i)
{
System.out.println("int[]");

}
// void f(String i)             //这里如果去掉注释的话，就会报错
// {
// System.out.println("String");
//
// }
void f(Object i)
{
System.out.println("object");
} public static void main(String[] args) {
new TestNull().f(null);

}
}

Answer 8

但是对于null来说，在编译期间，系统就知道它是一个string,也是一个object。所以系统自然选择更适合的string为参数的函数系统怎么看待NULL 是STRING 还是OBJECT? 
我的理解 NULL是空对象 不是STRING,而STRING 本身又是对象..所以就搞不懂到底应该优先谁了? 

Answer 9

我倒
null传递给 string 和 object作为参数的同名函数的时候，java 不会报错，java 自动识别为string，因为string是object的子类。当 null传递给int[]和object作参数的函数时，同理，识别为int[]。只有当string 传递给int[] 和 string作参数的同名函数时，才会出现混淆。因为int[]和string之间没有继承关系。所以系统无法分辨哪个更为贴近。
  再不明白，我也无语了

Answer 10

估计这只是java对overload函数做匹配的一个顺序的问题.首先匹配子类,再去尝试超类,这个例子中,如果有两个object的子类的话,就会有二义性错误了.

Answer 11

原来的那个应该会编译出错， 因为 Overload 后的 当使用 null 无法判断使用哪个 方法。其实你自己能看出来，编译器就能看出来 ，你自己确定看不出来 ，那么 编译器也看不出来 。

Answer 12

搞清楚了。。java好象把null看成通用对象MyMyString是Object, MyString也是Object。然后java需要判断null到底是属于哪个？  从下面的sample看来。java会把null看成是继承关系最下面的叶子的哪个Class..测试以下下面的程序就知道了
public class MyTest
{
    public void f(MyString s)
    {
        System.out.println("MyString");
    }
    public void f(MyMyString s)
    {
        System.out.println("MyMyString");
    }
    public void f(Object s)
    {
        System.out.println("Object");
    }
    /**
     * @param args
     */
    public static void main(String[] args)
    {
        // TODO Auto-generated method stub
        new MyTest().f(null);
    }}class MyString extends Object
{
    
}class MyMyString extends MyString
{
    
}

Answer 13

继承关系Object<---MyString<---MyMyString
MyMyString是继承关系的叶子。。所以系统判断null是MyMyString

Answer 14

overload跟overwrite的问题，这里应该是说String是Object的子类，重写了。

Answer 15

终于看到最有说服力的东西结帖了 谢谢各位
更感谢  wthwebbe(honghong) ( ) 信誉：97