java笔记12 内部类

 

1.     内部类

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

2.      内部类分类

成员内部类：在成员变量位置上的内部类

静态内部类：静态的内部类

方法内部类：定义在方法中的内部类

匿名内部类：匿名的内部类

3.    内部类访问规则

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

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

4.    成员内部类

当内部类定义在外部类中的成员位置上，可以使用一些成员修饰符修饰 private、static。

1、默认修饰符。

直接访问内部类格式：外部类名.内部类名变量名 = 外部类对象.内部类对象;

Outer.Inner in= new Outer.new Inner();//这种形式很少用。

       但是这种应用不多见，因为内部类之所以定义在内部就是为了封装。想要获取内部类对象通常都通过外部类的方法来获取。这样可以对内部类对象进行控制。

2、私有修饰符。

通常内部类被封装，都会被私有化，不让其他程序直接访问。

3、静态修饰符（也就是静态内部类）。

       如果内部类被静态修饰，相当于外部类，会出现访问局限性，只能访问外部类中的静态成员。

注意：如果内部类中定义了静态成员，那么该内部类必须是静态的。

       示例：  

public class Test5
{
         public static void main(String[] args)
         {
                   new Outer().outerShow();//调用外部类的方法，产生了一个内部类，并调用内部类方法
         }
}
 class Outer
 {
          private int x=3;
          //定义一个普通外部函数
          void outer()
          {
                    System.out.println("outerShow");
          }
          //创建内部类，并定义内部类函数，调用外部私有成员变量和函数
          class Inner
          {
                    //内部类函数可以直接调用外部函数，如果是静态内部类，只能调用静态函数
                   void innerShow()
                   {
                            System.out.println(x);
                            outer();
                   }
          }
          //定义一个调用内部类函数的函数，如果在outer()中调用内部类函数，会变成死循环。
          void outerShow()
          {
                    Inner in=new Inner();
                    in.innerShow();
          }
}

 

5.    方法内部类（局部内部类）

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

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

3、可以访问所在局部中的局部变量，但必须是被final修饰的。

public class H_04Inter
{
                   public static void main(String[] args)
                   {
                            new outer ().method(7);
                   }
}
class outer
{
                   int  x=3;
                   void method(final inta)//形式参数也必须是final的
                   {
                                     finalint Y=4;
                                     class Inner//不能加静态，不是成员
                                     {
                                               void function()//不能加静态
                                               {
                                                        System.out.println(a);
                                               }
                                     }
                                     new Inner().function();//必须放在下面，方法中的代码是按顺序执行的
                   }
}

结果：7

备注：在jdk1.8中，局部内部类访问的局部变量可以不用final修饰（不加final可以通过编译），但是变量实际上仍具有final特性。

原因：局部变量是在栈内存中，类对象时加载在堆内存，类的生命周期比局部变量长。

6.      匿名内部类

6.1  定义

没有名字的内部类。就是内部类的简化形式。一般只用一次就可以用这种形式。匿名内部类其实就是一个匿名子类对象。想要定义匿名内部类：需要前提，内部类必须继承一个类或者实现接口。

6.2  格式

new　父类或者接口()

{

               定义子类的内容

}.方法名();

匿名内部类中定义的方法最好不要超过2个，

方法少的时候直接调用方便。

方法多的时候用实名内部类。

public class H_04NiMingInterTest
{
         public static void main(String[] args)
         {
                   Test.function().method();
                   //Test 中有一个静态的方法 叫做function
                   // function的返回值是一个可以调用method方法的对象
         }
}
interface Inter
{
         void method();
}
class Test
{
         static Inter function()//静态的，可以直接被调用，返回值是一个内部类对象
          {
                  return new Inter()//匿名内部类类
                    {
                             public void method()
                             {
                                                System.out.println("test");
                                    }       
                    };
          }
}

结果：test

6.3  没有父类也没有接口，可以通过object类来实现匿名内部类，但是不要实例对象，因为Object类中没有子类的特殊方法。

new object()

{
         publicvoid function()

{

}

}.function();