黑马程序员_Object和内部类

------Java培训、Android培训、iOS培训、.Net培训、期待与您交流！ ------- 

Object和内部类

一、Object类

Object类是层次类结构的根类，就是所有对象的直接父类或间接父类。里面一定定义的所有对象的都具备的功能。这个是隐式的。就相当于：

                class  Demo extends  Object

而extendsObject 其实是隐式的，但确实继承了Object类，并且具有类中的方法。查看API文档，常用的方法有：

equals（Object）方法，比较对象是否相等，其实是比较对象地址值是否相等。而且，这方法接收的是一个Object类型的对象，既然Object是所有类的父类，那么这里就实现了多态。在我们应用的是，我们可以复写其中的equals方法，进行我们想要进行的比较方法。复写的是时候，注意的一点就是：接收的参数是Object类型，不能改变，否则就不是复写，所以当我们比较对象中特有数据时候，复写中还要加上一些判断和类型向下转型的动作。

toString（）方法，返回该对象的字符串形式。

getClass（）方法，这方法在反射时常用。返回此Object运行时的类，注意是类。返回值为Class。重点说下这个方法，首先我们创建对象时会加载相关的类文件，而类文件里面有关于食物的具体描述，比如说名称、方法和功能，而这类class文件在硬盘里是一个个实实在在的个体，可以把这些文件看做是对象，那么以面向对象的概念来说，这些class文件就会有一个类来描述它，这个类就是Class，只是名字起为Class。

当我们使用getClass方法时，就返回了一个类型为Class的引用，程序如下：

                 Class  c  = 对象.getClass();

这就把对象相对应的Class类型返回了，我的理解是，把描述这个对象的类文件整体返回了，有了这个对象的类文件，通过引用c，我们就可以获取这个类的名字，方法，参数等等。

而Class这个类中还有好多方法，比如getName()，就可以返回这个类的名字。

不部分一定要了解，熟悉。

我们再返回来看toString()，它就是返回对象的类名加上哈希值。其中的程序为：

          d.getClass().getName()+”@”+Integer.toHexString(d.HashCode())

当然toString方法也是可以复写的，写成我们想要的方法。

 

 

总结来说：

1）  Object类是所有类的父类。所以Object的引用可以接受其他任何子类对象，这里就是多态。

2）  其他类是隐式继承Object类，具有Object了方法

3）  复写Object的方法时，要注意如果使用子类特有方法，要向下转型，必要时要做一些判断。比如euqals（）方法的复写。

4）  重点理解getClass（）方法，这对后期学习反射来说挺重要

 

二、内部类

定义上，将一个类定义在另一个类里面，对里面那个类就称为内部类。

 

格式来说：

class A {

      int x ;

                    classB {  //内部类

         int y =0;

}

}

这里B类就是内部类。

既然内部类在外部类里面，就相当于一个外部类中的一个成员，所以就内部类就可以直接访问外部类成员，私有的成员也是可以访问的。而外部类缺不能直接访问内部类的成员，必须先建立内部类对象才可以访问。

方式一，建立内部类对象，访问内部类成员，程序为：

         classOuter{

         privateint x=0;

         classInner{

                   voidfunction(){

                            System.out.println("neibu lei ");

                   }

         }

         voidmethod(){  //外部类建立访问方式

                   Innerin = new Inner();  //建立内部类对象

                   in.function();      //调用内部类的方法

         }

}

之后只要在主函数中建立Outer的对象，调用method方法即可。

方式二，直接在主方法中访问内部类成员。程序为：

       在主函数中：

            Outer.Inner  in = new Outer().newInner();

                             in.function(); //直接调用内部类成员

     这里原因是因为内部类依存于外部类，所以要前面表示是外部类，也就是相当于内部类的一个成员。这样，内部类就可以被private修饰，成员么，就可以修饰的。

 个人理解来看，内部类也是一个类，但是给他上了一个标签，做好多事都得呆着这标签。

 

总结来说：

1）  内部类可以直接访问外部类中的成员，包括私有成员

2）  之所以可以直接访问外部类中的成员，因为内部类中持有一个外部类的引用

3）  外部类要访问内部类，必须建立内部类对象

4）  当内部类定义在外部类成员位置上，而且不是私有的，就可以再主函数中直接建立内部类对象，格式就是方式二

5）  当内部类在成员位置上，就可以被成员修饰符修饰，比如private修饰符修饰。

6）  当内部类被static修饰时，就成静态内部类，这时内部类只能直接访问外部类中的static成员

外部其他类，访问static内部类的非静态成员

             new Outer.Inner().function();

外部其他类，访问static内部类的静态成员

              user.Inner.function();

以上两个实际开发中用的都比较少。

7）  注意：当内部类定义了static成员，内部类也必须是静态的

8）  当外部类的静态方法访问内部类时，内部类也必须是static的

三、内部类定义原则

类是描述现实中事物，当描述事物时，事物的内部还有事物，该事物用内部类来描述，因为内部事物在只用外部事物的内容。

就比如描述电脑，而电脑里有显示器，键盘，而它们各有各的功能属性和行为，但是这两个又和电脑本身有联系，所以按照现实生活联系来说，这样就可以定义内部类，这样是最优的。

 

四、匿名内部类（常用）

1、内部类定义在局部中

内部类可以定义在外部类中的成员部分或者局部部分。如果内部类放在局部的时候，要在局部建立内部类对象并调用内部类里的方法时，对象建立要在内部类语句后面。具体程序为：

class Outer

{

         voidmethod(){

                   classInner

                   {

                            boidfunction(){

                                     语句；

                            }

                   }

                   newInner().function();//建立对象语句必须在内部类之后

         }

}

需要注意的是：1）内部类定义在局部时，不可以被成员修饰符修饰

              2）内部类定义在局部时，可以直接访问外部类成员，因为持有外部类中的引用

              3）内部类定义在局部时，不可以访问它所在的局部中的变量，只能访问被final修饰的局部变量。

 

就上上述程序中，method方法中如果加入一个局部变量，或者加入引用参数（也就是局部变量），那么想要内部类引用的话，就要加上final。程序如下：

         voidmethod(final int x ){

                   classInner

                   {

                            final int y =3;

                            boidfunction(){

                                     System.out.println(x);

                                     System.out.println(y);

                            }

                   }

                   newInner().function();

         }

 

2、匿名内部类

匿名内部类其实就是内部类的简写格式

先看一段程序：

         classOuter{

         privateint x=0;

         classInner{

                   voidfunction(){

                            System.out.println("neibu lei ");

                   }

         }

         voidmethod(){ 

         newInner() .function();     

         }

}

Inner为内部类，我们想要的是一个匿名的内部类，那这类类就没有名字：

                      class {  方法 }

那么这个内部类既然没有名字，那么在外部类就无法创建其对象，这就涉及到匿名内部类定义的前提：内部类必须是继承一个类或者实现接口。

有这样一个前提，那么就可以通过多态，即父类或接口的引用来指向对象，把斜体的部分：

         classOuter{

         privateint x=0;

         class extends Advice{

                   voidfunction(){

                            System.out.println("neibu lei ");

                   }

         }

         voidmethod(){ 

                  new Inner() .function();       

         }

}

改为如下程序:

         voidmethod(){ 

     new Advice(){

         voidshow(){

                   System.out.println(“neibu lei”);

}

}

         }

}

这就是匿名内部类的写法，这就是上面的斜的部分的简写，这是一个对象，是一个子类的对象。既然这就是一个对象，那么在大括号最后可以加  .fucntion();   进行方法调用，程序如下：    newAdvice(){

                            voidshow(){

                             System.out.println(“nei bu lei”);

}

}.function();

个人认为，就是内部类继承一个类或实现一个接口时，我们引用内部类时，直接在方法中建立匿名内部类，相当于接口引用后直接在内部写入内部类实现的功能即可，这就是一个大的对象，这个对象就是内部类的对象，就可以用多态给他起名字然后按照对象的方法调用其中的方法即可。

 总结来说：

1）  匿名内部类时内部类的简写格式

2）  定义匿名内部类的前提：内部类必须继承一个类或实现接口

3）  匿名内部类格式： new 父类或几口( ) { 定义子类内容 }

4）  匿名内部类其实就是一个匿名的子类对象（就是那个内部类的对象），只是少名字，加入内部类的内容，本质上还是一个对象，而且是子类对象。

5）  匿名内部类中定义的方法最好是一到两个

6） 匿名内部类可以作为参数传递，这样方便很多，之后用到会很多

就是说，我的一个方法 method（Interface in），要传入一个接口类型的对象，那么通常的方法就是建立一个类，这个类实现这个接口的方法，然后利用多态传入这个类的对象。现在有了匿名内部类，就可以直接建立匿名内部类传入，具体程序为：

         public static void show ( new Advice(){

                                            void show(){

                                         System.out.println(“nei bu lei”);

}

}

);

 

 

注意：即便是内部类中没有继承一类或实现接口，但是它有父类Object，同样可以创建匿名内部类。