java 面试题！

Question

public class Test 
 {
        
       
   
    
    private void print(Integer some)
    {
     System.out.println("Integer");
    }
    
    private void print(Object some)
    {
     System.out.println("Object");
    }
    
    public static void main(String[] args) 
    {
        
        
        Test test = new Test();
        test.print(null);
    }
    
    
}
请说出输出结果．为什么！！！

Answer 1

可能这里会将null当成整数，就像C中的0，它是个常量
不知道这么说站不站的住脚

Answer 2

System.out.println((null+"").length());
它等于4
可见它是个4字节的，这可能要研究他的存储方式了

Answer 3

System.out.println((null+"").length());
它等于4
可见它是个4字节的，这可能要研究他的存储方式了
－－－－－－－－－
这个不就是"null"有4个字符吗，怎么扯到字节、存储方式上去了
还有，跟c中的0是两码事，这里都是对象

Answer 4

我觉得这里的null既可以满足Integer的要求也可以满足Object的要求,只是Integer是更具体的类就先满足他了大家可以试试这个看返回什么
public class test 
 {        
    private void print(Object some)
    {
    System.out.println("Object");
    }
    private void print(int some)
    {
    System.out.println("Integer");
    }    
    public static void main(String[] args) 
    {       
        test test1 = new test();
        test1.print(null);
    }    
}

Answer 5

int跟Object没有可比性两者都匹配的时候，涉及到强制转换，选择强制转换后信息丢失最少的那个，所以就选择了Integer
纯属个人意见

Answer 6

重载方法的匹配问题
Integer 作为int的封装类,其初始值是null,而不是0.所以,这里你输入参数null,jvm就会调用与参数匹配间隙最小的方法.所以......

Answer 7

believefym(feng) ( ) 信誉：100    Blog  2007-2-3 10:52:01  得分: 0  
 
 
   
int跟Object没有可比性两者都匹配的时候，涉及到强制转换，选择强制转换后信息丢失最少的那个，所以就选择了Integer
纯属个人意见  
 
/////////////////////////////////////
我也不是很清楚，查了半天没找到，你说是怎么回事呢？

Answer 8

System.out.println((null+"").length());
它等于4
可见它是个4字节的，这可能要研究他的存储方式了
－－－－－－－－－
这个不就是"null"有4个字符吗，怎么扯到字节、存储方式上去了
////////////////////////////////////////////////////////////////
这就代表null有四个字符？===您的意思是null="null"
也就是
System.out.println((null+"").length());==System.out.println(("null"+"").length());
嗬嗬，我也不清楚，请给讲一下好吗？学习学习

Answer 9

重载方法的匹配问题
Integer 作为int的封装类,其初始值是null,而不是0.所以,这里你输入参数null,jvm就会调用与参数匹配间隙最小的方法.所以......////////////////////////////////////////
看来得恶补基础了。
给楼主道歉
学到了些东西
谢谢高手指点

Answer 10

为什么是Integer而不是Object尼，null 是个到底算什么了，高手来诉！！

Answer 11

因为匹配都是从子类开始匹配的,所以会匹配到Integer

Answer 12

把private void print(int some)
{
System.out.println("Integer");
}这个方法去掉，就是Object了，真晕/

Answer 13

Integer 是 Object 的派生类

Answer 14

...... Integer 是对象啊  null是空对象 他符合第一个print方法的参数类型 当然走第一个方法所以结果就是Integer啊

Answer 15

object 是所有类型的最上层类型 应该不能用来赋值吧

Answer 16

我觉得 lbfhappy(千里冰封)  说的不错.

Answer 17

如果说是子类派生出来的话。如果改成String 和int的时候就显示的是Object 这又能说名什么呢？在一个。如果是方法重载的话那么具体的运行过成是什么呢？请高手解释下。如果都是对象的话。换成能是存放NULL的对象会说名这个方法的真实性么?

Answer 18

在这里，NULL既是Integer的对象，也是Object的对象，而且Integer类继承于Object 类，所以在这种情况下，沿着继承的路线从下往上搜索匹配的情况

Answer 19

其实fairyskydlj() 已经说得很清楚了
在这里，NULL既是Integer的对象，也是Object的对象，而且Integer类继承于Object 类，所以在这种情况下，沿着继承的路线从下往上搜索匹配的情况——fairyskydlj()
我再给你个例子
class Humen 
{

}class Women extends Humen
{

}
class Man extends Humen
{

}public class Test 
{   
   private void print(Humen some)
   {
   System.out.println("Humen");    
   }
   
   private void print(Man some)
   {
   System.out.println("Man");    
   }
   public void print(Women some)
   {
   System.out.println("Women");
   }
   
   public static void main(String[] args) 
   {
       Humen hu = new Humen();       
   Humen hu_shangzhuan = new Man();
   Man man = new Man();   
       Test test = new Test();
       test.print(hu);
       test.print(hu_shangzhuan);
       test.print(man);
       test.print(null);
   }
}
这段代码在编译期会抱错，说是The method print(Humen) is ambiguous for the type Test
也就是说null既是Man,也是Women的对象。
所以你的结果应该是打印出Integer.

Answer 20

我觉得还是NULL既是Integer的对象，也是Object的对象，而且Integer类继承于Object 类，所以在这种情况下，沿着继承的路线从下往上搜索匹配的情况.

Answer 21

因为Integer是Object的子类，所以等于private void print(Integer some)重载了private void print(Object some)，所以调用总是先匹配private void print(Integer some)，至于null她是任意类型，所以他既可以是Integer又可以是Oject，但因为前面的原因，null按照Integer处理

Answer 22

如果说是子类派生出来的话。如果改成String 和int的时候就显示的是Object 这又能说名什么呢？在一个。如果是方法重载的话那么具体的运行过成是什么呢？请高手解释下。如果都是对象的话。换成能是存放NULL的对象会说名这个方法的真实性么?******************************************************
改成String 的时候应该显示的是Integer

Answer 23

看是简单的面试题多了，可是答对的确不多，我曾经被人问到 JAVA的8大基元数据是什么~我一激动说对了7个 还少个~  问问你自己 看看你能说对几个 当然是很流利的说出来~
还有啊 什么是数据库~  我一激动答了个：具有关联表的集合  呵呵~ 真的有点丢人，我到今天也不能用很简练的语言概括出到底什么是数据库。
我到网上找到的答案：
数据库是依照某种数据模型组织起来并存放二级存储器中的数据集合。这种数据集合具有如下特点：尽可能不重复，以最优方式为某个特定组织的多种应用服务，其数据结构独立于使用它的应用程序，对数据的增、删、改和检索由统一软件进行管理和控制。从发展的历史看，数据库是数据管理的高级阶段，它是由文件管理系统发展起来的。

Answer 24

如果把
private void print(Integer some)
    {
    System.out.println("Integer");
    }
去了
结果就会显示为Object
所以,是那个Integer类继承于Object 类，所以在这种情况下，沿着继承的路线从下往上搜索匹配的情况.
  应该没有错了

Answer 25

本人做了如下实验：
    private void print(Object some) {
        System.out.println("Object");
    }    private void print(int some) {
        System.out.println("Integer");
    }
    public static void main(String[] args) {        MainTest test1 = new MainTest();
        test1.print(null);    }
// 结果 object＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
然后，调换print的位置：
 private void print(int some) {
        System.out.println("Integer");
    }
    
    private void print(Object some) {
        System.out.println("Object");
    }    public static void main(String[] args) {        MainTest test1 = new MainTest();
        test1.print(null);    }
// 结果还是object
==============================================无论print的顺序怎样，eclipse都有如下信息
the method print(int) from the type xx is never used locally.
==============================================
原因不明。

Answer 26

测试结果确实是这样,沿着继承的路线从下往上搜索匹配.如果不存在继承关系这样的写法是错误的
public class Test 
 {     private void print(java.util.List  some)
     {
     System.out.println("Object");
    }
    private void print(java.util.ArrayList some)
    {
    System.out.println("Integer");
    }    public static void main(String[] args) 
    {
        Test test = new Test();
        test.print(null);
    }
}

Answer 27

fairyskydlj() 
说的对，好像在java解惑的那本书里，已经讨论过这个问题，说的原因就是fairyskydlj() 说的那个。

Answer 28

SCJP 5.0 认证专家：F*cking compile error!!

Answer 29

哦。原来是这样的啊。就是会自动找匹配的类型。是从最小的类开始找起的是么？如果到最后没有匹配的指的话就是所有对象类的基类OBJ您们说的是这个意思么？

Answer 30

to luyang1016(闭月羞花猫) 
因为int是简单类型，null是对象

Answer 31

大家看一下这段代码：
public class Test{
    private void print(){
        System.out.println("helloWorld");
    }
    private void print(Object some){
        System.out.println("Object");
    }
    private void print(Integer some){
        System.out.println("Integer");
    }
    private void print(String some){
        System.out.println("String");
    }
    public static void main(String[] args){
        Test test = new Test();
        test.print(null);
        //System.out.println((null).length());
    }
}
首先说明，它是编译不通过的。
String和Integer都是基本类型的包装类，它们默认的初值是null，当出现一个null的参数时，它就去找它最近的匹配
在这个例子中说明参数匹配是先从子类开始再到父类，Object 是所有类的父类，所以只要有一个别的类的实例，就肯定轮不到它。
但是出现两个没有继承和被继承关系的类中，它们就没有办法匹配了。

Answer 32

luyang1016(闭月羞花猫) ( ) 信誉：100    Blog  2007-02-05 09:10:36  得分: 0  
 
 
   本人做了如下实验：
    private void print(Object some) {
        System.out.println("Object");
    }    private void print(int some) {
        System.out.println("Integer");
    }
    public static void main(String[] args) {        MainTest test1 = new MainTest();
        test1.print(null);    }
// 结果 object＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝＝
然后，调换print的位置：
 private void print(int some) {
        System.out.println("Integer");
    }
    
    private void print(Object some) {
        System.out.println("Object");
    }    public static void main(String[] args) {        MainTest test1 = new MainTest();
        test1.print(null);    }
// 结果还是object
==============================================无论print的顺序怎样，eclipse都有如下信息
the method print(int) from the type xx is never used locally.
==============================================
原因不明。
  
出现 the method print(int) from the type xx is never used locally.
并没有什么原因不明的，就是你的print(int)方法没有不你的本地程序所调用

Answer 33

java是单根继承的，任何类根基类都是Object，它是个超类。注意楼主的重载方法的参数是Integer,不是int，Integer在Java中也是从Object继承过来的。在java中也不是所有的都是对象，也包括int,double...等基础数据类型，Integer是个类，是对象，是对int小数据类的封装。楼主运行下面的代码，看看输出的是什么结果。import java.util.Vector;public class Test {
public void print(Object obj){
System.out.println("Object");
}
public void print(Vector v){
System.out.println("Vector");
}

public void print(MyVector v){
System.out.println("MyVector");
} public static void main(String[] args) {

Test test = new Test();

test.print(null);

}}class MyVector extends Vector{

}

Answer 34

java.lang.Object
  ->java.lang.Number
      ->java.lang.Integer

Answer 35

向上转型
Integer类派生与Object类
当传递的参数null与Integer对象匹配，转成Integer对象，
否则如果没有Integer参数的方法，继续向上转型成Object对象。

Answer 36

Integer~java的重载解析选取的对象（都满足的时候）它会选择比较精确的那个over
(详细请参看java解惑 p106面）
偶以后可能不会用java了 5555555555555555555555555555~~~ 
还是c和c++好

Answer 37

我的问题是null也是对象？在这里看来。

Answer 38

没事多看看所谓大师的书还是好，java解惑的2个作者太强鸟

Answer 39

public class Test { public void print(Integer t) {
System.out.println("t");
}

public void print(String t) {
System.out.println("str");
}
public static void main(String[] args) throws UnknownHostException {
Test t=  new Test();
t.print(null);
}
}
这样输出的是什么？

Answer 40

为什么加上t.print(null);这句话，就编译不动过了呢？呵呵

Answer 41

对null的解释：
null,对象没有实例话。no instance.
在此，将null作为参数，在运行时会动态绑定，向上转型。这也是多态的原理。
在此，null先转化成Integer类的对象。而不会继续向上转型成Object.
至于String,int等数据类型非类，没有封装，所以与封装成对象的没有可比性。null在此可以转型，是一个奇怪的东西。null也是对象。null是所有类的对象，包括你自己定义类的一个未实例化的对象。
null是所有类的对象，包括你自己定义类的一个未实例化的对象。
另外public class Test 
 {    
    private void print(Integer some)
    {
    System.out.println("Integer");
    }
    
    private void print(Object some)
    {
    System.out.println("Object");
    }
    private void print(a some)
    {
    System.out.println("a");
    }
    
    
    public static void main(String[] args) 
    {  
        Test test = new Test();
        test.print(null);
    }}
class a{}
出错。把print(object)与print(integer)去掉，运行正常。
说明null是所有类的对象，而Integer与a同时出现出错，是向上转型模糊以上问题总结两点：
1、向上转型
2、null是所有类的对象

Answer 42

同意 eric_ranch() 以上问题总结两点：
1、向上转型
2、null是所有类的对象

Answer 43

public class Test {
private void print(Object some) {
System.out.println("Object");
}

// private void print(Integer some) {
// System.out.println("Integer");
// }

private void print(String some) {
System.out.println("String");
} public static void main(String[] args) { Test test = new Test();
test.print(null);
}}结果:
String我认为:
Top 回复人：blh(股市奋斗几十年，一夜回到解放前: () ( ) 信誉：100 2007-02-04 23:09:46 得分:0
因为Integer是Object的子类，所以等于private void print(Integer some)重载了private void print(Object some)，所以调用总是先匹配private void print(Integer some)，至于null她是任意类型，所以他既可以是Integer又可以是Oject，但因为前面的原因，null按照Integer处理

Answer 44

qiuqiupeng(打老婆真爽)
总结的太清楚了，把所有的问题点都说清楚了，
一个是继承，一个是重载

Answer 45

null是所有类的对象 ??????????????????????????????
-------------------------------------------------
null instanceof String           false
null instanceof Integer          false
null instanceof Object           false
-------------------------------------------------
null 不属于任何类。null 本身就是一个单独的对象

Answer 46

null应该只是一个空的引用，而函数的形参也是引用，所以能比配
同意重载的说法

Answer 47

Integer  null也是一个对象

Answer 48

Integer为int的封装类，它的初始值为null