内部类

Posted 2020-08-22 程序员简笔

     定义：在一个类中再定义一个类，则将在类中定义的那个类成为内部类。具体分为有五种：

1.成员内部类

      （1）定义：在一个类中使用内部类，可以在内部类中直接存取其所在类的私有成员变量。

            用法：在内部类中可以随意使用外部类的成员方法及成员变量。

     例：

 1 public class OuterClass {
 2     innerClass in = new innerClass(); // 在外部类实例化内部类对象引用
 3     
 4     public void ouf() {
 5         in.inf(); // 在外部类方法中调用内部类方法
 6     }
 7     
 8     class innerClass {      //内部类的定义
 9         innerClass() { // 内部类构造方法
10         }
11         
12         public void inf() { // 内部类成员方法
13         }
14         
15         int y = 0; // 定义内部类成员变量
16     }
17     
18     public innerClass doit() { // 外部类方法，返回值为内部类引用
19         // y=4; //外部类不可以直接访问内部类成员变量
20         in.y = 4;//通过内部类对象引用调用内部类成员变量
21         return new innerClass(); // 返回内部类引用
22     }
23     
24     public static void main(String args[]) {
25         OuterClass out = new OuterClass();
26         // 内部类的对象实例化操作必须在外部类或外部类中的非静态方法中实现
27         OuterClass.innerClass in = out.doit();
28         OuterClass.innerClass in2 = out.new innerClass();
29     }
30 }

      分析：内部类可以访问外部类的成员，但内部类成员只能在内部类的范围之内是可以被使用，不能被外部类使用，但可以使用内部类对象引用调用内部类成员变量。

在上面的例子中，如果不使用doit（）方法返回内部类对象的引用，可以直接使用内部类实例化内部类对象，但是由于是在主方法中实例化内部类对象，必须在new操作符之前提供一个外部类的引用。如下例子中在主方法中实例化一个内部类对象：

public static void main(String [] args){
    OuterClass out = new OuterClass();
    OuterClass.innerClass in = out.doit();
    OuterClass.innerClass in2 = out.new innerClass();   //实例化内部类对象
}

   分析：上例中在实例化内部类对象时，不能再new操作符之前使用外部类名实例化内部类对象，而是应该使用外部类发的对象来创建其内部类对象。

   （2）内部类向上转型为借口

      例:

 1 package com.lzw;
 2 interface OutInterface { // 定义一个接口
 3     public void f();
 4 }
 5 //主类
 6 public class InterfaceInner {
 7     public static void main(String args[]) {
 8         OuterClass2 out = new OuterClass2(); // 实例化一个OuterClass2对象
 9         // 调用doit()方法，返回一个OutInterface接口
10         OutInterface outinter = out.doit();
11         outinter.f(); // 调用f()方法
12     }
13 }
14 
15 class OuterClass2 {
16     // 定义一个内部类实现OutInterface接口
17     private class InnerClass implements OutInterface {
18         //内部类InnerClass 实现了OutIntreface接口
19         InnerClass(String s) { // 内部类构造方法
20             System.out.println(s);
21         }
22         
23         public void f() { // 实现接口中的f()方法
24             System.out.println("访问内部类中的f()方法");
25         }
26     }
27     //OuterClass2类中的方法，返回一个外部接口类型
28     public OutInterface doit() { // 定义一个方法，返回值类型为OutInterface接口
29         return new InnerClass("访问内部类构造方法");
30     }
31 }

分析：从上述例子中可以看出，OuterClass2类中定义了一个修饰权限为private的内部类，这个内部类实现了接口，然后修改doit（）方法，使该方法返回一个接口，由于内部类接口修饰权限为private，所以除了OuterClass2类可以访问内部类之外，其他类都不能访问，而可以访问OuterClass2类中的doit（）方法，由于该方法返回一个外部接口看、类型，这个接口可以作为外部使用的接口。它包含一个f（）方法，在继承此接口的内部类中实现了该方法，如果某个类继承了外部类，由于内部类的权限不可以向下转型为内部类InnerClass，同时也不能访问f（）方法，但可以访问接口中的方法。

 （3）.使用this关键字获取内部类与外部类的引用

       如果在外部类与内部类中同时存在一个相同名称的成员变量，可以使用this关键字

例：

 

public class TheSameName{
  private int x;
  private class Inner{
  public void doit(int x){
      x++;                                  // 调用形参x
      this.x++;                             //调用内部类的变量x
      TheSameName.this.x++;                 //调用外部类的变量x
   }
  }
}