(9)面向对象内部类

 

1…

 

1.1

内部类定义;

将一个类定义在另一个类的里面，对里面那个类就称为内部类（内置类，嵌套类）。

 

1.2…

内部类的访问特点：

内部类可以直接访问外部类中的成员，包括私有成员。私有变量在本类中有效,而这内部类就在本类中,所以没有问题

 

而外部类要访问内部类中的成员必须要建立内部类的对象。

 

内部类里面跟其他类定义是一样的里面可以定义成员,方法变量

1.3..

内部类的访问规则：

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

       之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

b，外部类要访问内部类，必须建立内部类对象。

 

代码:

class Outer

{

       privateint x = 3;

 

      

       classInner//内部类

       {

              //intx = 4;

              voidfunction()

              {

                     //intx = 6;

                     System.out.println("innner:"+x);

              }

       }

 

       /**/

       voidmethod()

       {

              Innerin = new Inner();

              in.function();

       }

}

 

//想访问内部类那么得先有外部类,你得先有外部类对象才有内部类对象

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

 

内部类也是外部类中的一成员,成员就能被封装私有private class Inner,有可能把内部类封装,用私有修饰,,内部类可以被私有修饰,当内部类在外部类的成员位置上时就可以被私有修饰

 

 

 

2…内部类的访问规则

 

 

内部类的访问规则：

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

       之所以可以直接访问外部类中的成员，是因为内部类中持有了一个外部类的引用，格式 外部类名.this

b，外部类要访问内部类，必须建立内部类对象。

 

访问格式：

a,当内部类定义在外部类的成员位置上，而且非私有，可以在外部其他类中可以直接建立内部类对象。。InnerClassDemo就是一个外部其他类

 

格式

       外部类名.内部类名  变量名 = 外部类对象.内部类对象;

       Outer.Innerin = new Outer().new Inner();

 

b,当内部类在成员位置上，就可以被成员修饰符所修饰。

       比如，private：将内部类在外部类中进行封装。外界就不知道了

              static:内部类就具备了static的特性。成员修饰符里有静态,内部类可以被静态修饰

              当内部类被static修饰后，只能直接访问外部类中的static成员。也就是出现了访问局限。

 

              在外部其他类中，如何直接访问static内部类的非静态成员呢？

              newOuter.Inner().function();Outer.Inner是个整体,直接new他Outer.Inner的对象,,,Inner是静态的所以Outer类名可以直接调用,类名调用完Outer.Inne就是内部类了,所以new一个内部类对象没有问题

 

              在外部其他类中，如何直接访问static内部类的静态成员呢？

              Outer.Inner.function();

 

       注意：当内部类中定义了静态成员，该内部类必须是static的。

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

 

c.. 当外部类中的静态方法访问内部类时，内部类也必须是static的。

 

class Outer

{

       privatestatic  int x = 3;

       staticclass Inner2

       {

              voidshow()

              {

                     System.out.println("inner2show");

              }

       }

 

       publicstatic void method()   当外部类中的静态方法访问内部类时，内部类也必须是static的。Inner2和method()  都是类中成员,静态的方法访问的是静态变量,所以Inner2也是静态

       {

              //Inner.function();

              newInner2().show();

       }

 

d.. 当内部类中定义了静态成员，该内部类必须是static的。

 

 publicclass Outer {

       privateint x = 3;

 

      

       classInner

       {

              staticvoid function()            function()编译报错,内部类不能有静态声明

              {

                     System.out.println("innner:"+x);

              }

       }

 

 

 

2…深入理解内部类

 

2.1…

内部类一般不会被共有修饰的,,一般是私有

 

内部类怎么来的:

 

当描述事物时，事物的内部还有事物，该事物用内部类来描述。

因为内部事物在使用外部事物中的内容。内存包括函数变量

 

当一个类需要直接访问到另外一个类中成员的时候,就把这个类写到那个类的里面去,写完后把这个内部类封装在这个类中不对外公布,而对外提供方法来访问这个内部类

class Body

{

       //定义内部类

       privateclass XinZang

       {

       }

 

       publicvoid show()

       {

              newXinZang().

       }

      

}

 

2.2.. 内部类可以写在一个类的任意外置上,成员也包括局部,方法里面写一个内部类,,访问规则不变,他还可以直接访问外部类中的成员

 

class Outer

{

       intx = 3;

 

       voidmethod(final int a)       {

             

              classInner  {‘

                     voidfunction()

                     {

                            System.out.println("都是");

                     }

              }

}

 

2.3…

内部类定义在局部时，

1，不可以被成员修饰符修饰

2，可以直接访问外部类中的成员，因为还持有外部类中的引用。

       但是不可以访问它所在的局部中的变量。只能访问被final修饰的局部变量。

 

class Outer

{

       intx = 3;

 

       voidmethod(final int a) {

              finalint y = 4;

              classInner

              {

                     voidfunction()

                     {

                            System.out.println(a);                  }

              }

      

              newInner().function();

             

       }

}

 

 

3…匿名内部类

 

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

b，定义匿名内部类的前提：

       内部类必须是继承一个类或者实现接口。

c，匿名内部类的格式：  new 父类或者接口(){定义子类的内容},,,这个()指的是构造函数,这个构造函数可以传参数

class InnerTest

{

 

       publicstatic void main(String[] args)

       {

              newObject ()  这个是 Object的子类对象

              {

                     publicvoid function()

                     {

                           

                     }

                    

              };

 

 

       }

}

       //匿名内部类,,d变量引用的是AbsDemo的子类对象

       AbsDemod = new AbsDemo()

              {

                    

                     voidshow()

                     {

                            System.out.println(x);

                     }

                     voidabc()

                     {

                            System.out.println("haha");

                     }

              };

e，其实匿名内部类就是一个匿名子类对象。而且这个对象有点胖。可以理解为带内容的对象。匿名内部类是一个子类对象,是把定义类和建立对象封装为一体的表现形式

f，匿名内部类中定义的方法最好不要超过3个。里面的方法不会超过3个最多2个或一个,因为匿名对象调用方法会方便

 

注意:

 

定义匿名内部类的前提：

       内部类必须是继承一个类或者实现接口。

 

匿名内部类弊端:不能调用自己特有的方法,如果是有名字的话调用自己的方法是可以的,向下转型后就可以调用,还有一个弊端是不能向下转型,,还有一个弊端:如果那个父类有很多抽象方法的话,那么匿名内部类里面的对象体就得重写那些方法