1. package com.itheima.zhangxiaoxiang;
   
2. 
   
3. public class DifferentsOfObject {
   
4. 
   
5.         
   
6.         public static void main(String[] args) {
   
7.                
   
8.                 String[] arrString = new String[]{};
   
9.                 int[] arrInt = new int[]{};
   
10.                
    
11.                 /*这句okay*/
    
12.                 Object[] arrObjectString = arrString;
    
13.                
    
14.                 /*这里报错，Type mismatch: cannot convert from int[] to Object[]*/
    
15.                 Object[] arrObjectInt = arrInt;
    
16.                 /*我根据张孝祥老师在“数组与Object的关系中讲的，理解的错误原因为int不是Object的子类，所以不行(int根本就不是类)”*/
    
17.                
    
18.                 /*但是，这个为什么可以*/
    
19.                 int i = 0;
    
20.                 print(i);
    
21.                 /*这个怎么解释，多态？？int不是类，跟不是Object的子类*/
    
22.                                         /*强制类型转化？？？int到Object？怎么说？*/
    
23.         }
    
24.         
    
25.         //这个函数毕老师最常用了吧
    
26.         public static void print(Object obj) {
    
27.                 System.out.println(obj);
    
28.         }
    
29. }
    

复制代码

除了8个原生数据类型之外，其他所有的类都直接或间接继承自Object，数组int[]也是一个类，所以它也继承自Object。

难道是自动封装成了Integer对象，猜的

万物皆对象，但是基本类型却不是对象，所以要把基本类型转换为他的对象模式，也就是自动装箱了，int i = 0,转为了Integer类型，所以可以去传入进去，这个是1.5的新特性，


int [] a1 = new int[3];
int [] a2 = new int[4];
int [][] a3 = new int[2][3];
String [] a4 = new String [3];
//
Object aObj1 =a1;
Object aObj1 =a4;
Object []aObj1 =a1;//错误，因为数组中装的是int类型的数据，int类型不是Object，所以不对，这个和你不是一样吗？？？
Object []aObj1 =a3;
Object []aObj1 =a4;

应该是自动装箱吧

黑马_许芸 发表于 2012-8-26 17:07
除了8个原生数据类型之外，其他所有的类都直接或间接继承自Object，数组int[]也是一个类，所以它也继承自Ob ...

嗯，你说的有道理。int[]被胁迫为了类？哈哈哈。

但是，数组int[]到底是不是一个类，它的真正的原理是什么？

百度了下，csdn有人说：“
数组不是类，但是实现了Object中的方法
按照Java语言规范的说法：Java数据类型分为两大类：基本数据类型和复合数据类型，其中复合数据类型包括数组、类和接口。”

Object是所有类的上帝，所有的类都是它的子类。哥们，你忘记了java中还有一个自动拆箱和装箱的功能了。装箱就是把基础类型封装成一个类。比如把int封装成Integer，这时你就不能把他当成一个数了，而是一个类了，对他的操作就需要用它的方法了。拆箱就是把类转换成基础类型。比如你算个加法什么的是不能用类的，就得把它转换成基本类型，jdk5以后已经可以自动转换了。

Object是所有类的父类哦

找到了一段代码，寻找问题答案的思路与方法，啧啧，我觉的贼经典：

1. int[] array = new int[10];
   
2.             Class clazz = array.getClass();
   
3.             System.out.println(clazz);
   
4.             Method[] methods = clazz.getDeclaredMethods();
   
5.             System.out.println(methods.length);
   
6.             for(Method m : methods){
   
7.                 System.out.println(m.getName());
   
8.             }
   
9. 
   
10.             Method[] methodz = clazz.getMethods();
    
11.             System.out.println(methodz.length);
    
12.             for(Method m : methodz){
    
13.                 System.out.println(m.getName());
    
14.             }
    
15.             
    
16.             Class superclass = clazz.getSuperclass();
    
17.             System.out.println(superclass.getName());
    
18. 
    
19.             Class[] interfaces = clazz.getInterfaces();
    
20.             for(Class i : interfaces){
    
21.                 System.out.println(i.getName());

复制代码

1. public class Test {
   
2.     public static void main(String[] args) {
   
3.         Name[] n = new Name[10];
   
4.         int[] a = new int[10];
   
5.         
   
6.         //打印类名
   
7.         //[I
   
8.         //[LName;
   
9.         System.out.println(a.getClass().getName());
   
10.         System.out.println(n.getClass().getName());
    
11.         
    
12.         //判断是否为Object或者其子类
    
13.         //true
    
14.         //true
    
15.         System.out.println(a instanceof Object);
    
16.         System.out.println(n instanceof Object);
    
17.         
    
18.         //从打印结果看，数组就是类，是Object的子类，只是他比较特殊，语言层面上没有提供        //具体的类名等，在编译期间特殊处理的
    
19.     }
    
20. }
    
21. 
    
22. class Name {
    
23.    
    
24. }

复制代码

额，你说得对。我确实没在哪本教材上看到说int[]是一个类。那我就贴一段代码吧。这段代码用到了instanceof 。

1. public class ThreeDimensionArrayTest
   
2. {
   
3.         public static void main(String[] args)
   
4.         {
   
5.                 int[][][] a = new int[2][3][4];
   
6. 
   
7.                 System.out.println(a instanceof int[][][]);
   
8.                 System.out.println(a[0] instanceof int[][]);
   
9.                 System.out.println(a[0][0] instanceof int[]);
   
10. 
    
11.                 for(int i = 0; i < a.length; i++)
    
12.                 {
    
13.                         for(int j = 0; j < a[i].length; j++)
    
14.                         {
    
15.                                 for(int k = 0; k < a[i][j].length; k++)
    
16.                                 {
    
17.                                         a[i][j][k] = 100;
    
18.                                 }
    
19.                         }
    
20.                 }
    
21.         }
    
22. }

复制代码

这是运行结果：

  
Object类是所有类的基类，
一个类如果没有继承其他类，那么就是Object的子类

这个我也不是很清楚

java中的int,String等基本类的父类都是Object，数组的父类也是Object，总之object是一切类的父类
int[] arrInt = new int[]{};
Object[] arrObjectInt = arrInt;//这句是错的，因为int[]是一个数组，也就是Object的对象，所以不能这样
可以写成这样Object arrObjectInt = arrInt;或者Object[] arrObjectInt = arrInt[];

just make a mark

唐见 发表于 2012-8-26 17:11
难道是自动封装成了Integer对象，猜的

我感觉也是这样

尼玛，我也遇到了类似的疑惑，龙兄敢有清晰的解答吗？

坐等回复。。

夏诗瑶 发表于 2012-9-21 01:42
尼玛，我也遇到了类似的疑惑，龙兄敢有清晰的解答吗？

看我九、十楼啊。
int[]没有提供可查询的API，但是通过9、10楼贴的代码测试结果来看，它是java内部识别的Object的子类。