那些java中的内部类

java内部类是从JDK1.1开始出现的，因此，很多人都不陌生，但是又会觉得不熟悉。原因是平时编写代码时可能用到的场景不多，用得最多的是在有事件监听的情况下。所以，这里将从四个方面做一个简单的总结：

一.内部类基础

在Java中，可以将一个类定义在另一个类里面或者一个方法里面，这样的类称为内部类。广泛意义上的内部类一般来说包括这四种：成员内部类、局部内部类、匿名内部类和静态内部类。下面就先来简单了解一下这四种内部类的用法。

1.成员内部类

　　成员内部类是最普通的内部类，它的定义为位于另一个类的内部，这里总结它的一些特性：

• 成员内部类可以无条件访问外部类的所有成员属性和成员方法（包括private成员和静态成员）
• 当成员内部类拥有和外部类同名的成员变量或者方法时，会发生隐藏现象，即默认情况下访问的是成员内部类的成员
• 在外部类中如果要访问成员内部类的成员，必须先创建一个成员内部类的对象，再通过指向这个对象的引用来访问
• 成员内部类是依附外部类而存在的，也就是说，如果要创建成员内部类的对象，前提是必须存在一个外部类的对象
• 成员内部类中不能定义任何静态成员变量或静态成员方法，但可以有静态常量。

   1 public class InnerClassDemo {
   2     public static void main(String[] args) {
   3         
   4         //必须先创建一个外部类对象，才能创建一个成员内部类的对象
   5         Outer outer = new Outer("Liming", 20);
   6         Outer.Inner inner = outer.new Inner();
   7         inner.show();
   8     }
   9 
  10 }
  11 
  12 class Outer{
  13     
  14     private static String name;
  15     private int age;
  16     private int score = 100;
  17     
  18     public Outer(String name, int age) {
  19         this.name = name;
  20         this.age = age;
  21         
  22         //外部类访问内部类的成员，必须先创建一个成员内部类的对象
  23         Inner inner = new Inner();
  24         System.out.println(inner.score);//80
  25     }
  26     
  27     class Inner{
  28         
  29         int score = 80;
  30         
  31         void show(){
  32             //内部类能够访问外部类的静态和私有成员
  33             System.out.println(name);//Liming
  34             System.out.println(age);//20
  35             
  36             System.out.println(score);//80
  37             /*
  38              * 发生隐藏现象，访问的是内部类的score属性，若要访问外部类的score属性，则需要这样的格式：
  39              *     外部类.this.成员变量
  40              *    外部类.this.成员方法    
  41              */
  42             System.out.println(Outer.this.score);//100
  43             
  44         }
  45     }
  46 }

代码示例:

public class InnerClassDemo {
    public static void main(String[] args) {
        
        //必须先创建一个外部类对象，才能创建一个成员内部类的对象
        Outer outer = new Outer("Liming", 20);
        Outer.Inner inner = outer.new Inner();
        inner.show();
    }
}

class Outer{
    private static String name;
    private int age;
    private int score = 100;
    
    public Outer(String name, int age) {
        this.name = name;
        this.age = age;
        
        //外部类访问内部类的成员，必须先创建一个成员内部类的对象
        Inner inner = new Inner();
        System.out.println(inner.score);//80
    }
    
    /*
     * 内部类也可以有一些访问控制修饰符，如private,public,protected
     *     此处采用默认访问权限，只能在同一个包中访问
     */
    class Inner{
        int score = 80; //static int score = 80; 直接报错，编译不通过
        void show(){
            //内部类能够访问外部类的静态和私有成员
            System.out.println(name);//Liming
            System.out.println(age);//20
            
            System.out.println(score);//80
            /*
             * 此处发生隐藏现象，访问的是内部类的score属性，若要访问外部类的score属性，则需：
             *    外部类.this.成员变量
             *    外部类.this.成员方法    
             */
            System.out.println(Outer.this.score);//100
            
        }
    }
}

注意：这段代码的执行顺序是：调用Outer构造器创建外部类对象 > 创建内部类对象 > 执行show方法 。

2.静态内部类

 静态内部类也是定义在另一个类里面的类，只不过在类的前面多了一个关键字static。

• 静态内部类是不需要依赖于外部类的，即是在没有创建外部类对象的情况下也可以创建静态内部类的对象
• 静态内部类只能访问外部类的静态成员，而不能访问外部类的非静态成员

代码示例：

public class InnerClassDemo {
    public static void main(String[] args) {
        
        //直接创建静态内部类的对象，不依赖于外部类
        Inner inner = new Inner();
        inner.show();
    }
}

class Outer{
    public static String name = "Liming";
    public int age = 20;
    
    static class Inner{
        void show(){
            //静态内部类只能访问外部类的静态成员而不能访问非静态成员
            System.out.println(name);//Liming
//            System.out.println(age); 直接报错，编译不通过
        }
    }

}

3.局部内部类

 局部内部类是定义在一个方法或者一个作用域里面的类，它和成员内部类的区别在于局部内部类的访问仅限于方法内或者该作用域内。

代码示例：

class People{
    public People() {
         
    }
}
 
class Man{
    public Man(){
         
    }
     
    public People getWoman(){
        class Woman extends People{   //局部内部类
            int age =0;
        }
        return new Woman();
    }
}

注意：局部内部类就像是方法里面的一个局部变量一样，是不能有public、protected、private以及static修饰符的。

4.匿名内部类

 匿名内部类应该是平时我们编写代码时用得最多的，在编写事件监听的代码时使用匿名内部类不但方便，而且使代码更加容易维护。

• 匿名内部类不能有访问修饰符和static修饰符
• 匿名内部类是唯一一种没有构造器的类，因为连类名都没有何来构造器
• 匿名内部类的使用范围非常有限，大部分匿名内部类用于接口回调，“new 匿名内部类”，这个类首先是要存在的。

代码示例：

scan_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });
         
        history_bt.setOnClickListener(new OnClickListener() {
             
            @Override
            public void onClick(View v) {
                // TODO Auto-generated method stub
                 
            }
        });

二.深入理解Java内部类

1.静态内部类与非静态内部类

• 静态内部类的创建不依赖于外部类，并且可以定义静态成员
• 非静态内部类依赖于外部类的创建而创建，并且不能定义任何的静态成员

解析：静态内部类不依赖于任何外部类，所以可以有自己的静态成员；而非静态内部类必须通过外部类创建，它的存在严格依赖于外部类，所以不能有自己的静态成员。

• 静态内部类只能访问外部类的静态成员，而不能访问任何非静态成员

解析：静态内部类不依赖于外部类，所以可在未创建外部类对象的情况下创建静态内部类的实例对象，而没有外部类对象就不能访问外部类的非静态成员。

2.成员内部类可以无条件访问外部类的成员

之前，我们已经讨论过了成员内部类可以无条件访问外部类的成员，那具体究竟是如何实现的呢？下面通过反编译字节码文件看看究竟。

• 事实上，编译器在进行编译的时候，会将内部类单独编译成一个字节码文件，命名方式为：外部类$内部类.class 或 外部类$X.class（X为一个整数）。

     

通过反编译工具，将内部类的字节码文件进行反编译，得到：

E:\Workspace\Test\bin\com\cxh\test2>javap -v Outter$Inner
Compiled from "Outter.java"
public class com.cxh.test2.Outter$Inner extends java.lang.Object
  SourceFile: "Outter.java"
  InnerClass:
   #24= #1 of #22; //Inner=class com/cxh/test2/Outter$Inner of class com/cxh/tes
t2/Outter
  minor version: 0
  major version: 50
  Constant pool:
const #1 = class        #2;     //  com/cxh/test2/Outter$Inner
const #2 = Asciz        com/cxh/test2/Outter$Inner;
const #3 = class        #4;     //  java/lang/Object
const #4 = Asciz        java/lang/Object;
const #5 = Asciz        this$0;
const #6 = Asciz        Lcom/cxh/test2/Outter;;
const #7 = Asciz        <init>;
const #8 = Asciz        (Lcom/cxh/test2/Outter;)V;
const #9 = Asciz        Code;
const #10 = Field       #1.#11; //  com/cxh/test2/Outter$Inner.this$0:Lcom/cxh/t
est2/Outter;
const #11 = NameAndType #5:#6;//  this$0:Lcom/cxh/test2/Outter;
const #12 = Method      #3.#13; //  java/lang/Object."<init>":()V
const #13 = NameAndType #7:#14;//  "<init>":()V
const #14 = Asciz       ()V;
const #15 = Asciz       LineNumberTable;
const #16 = Asciz       LocalVariableTable;
const #17 = Asciz       this;
const #18 = Asciz       Lcom/cxh/test2/Outter$Inner;;
const #19 = Asciz       SourceFile;
const #20 = Asciz       Outter.java;
const #21 = Asciz       InnerClasses;
const #22 = class       #23;    //  com/cxh/test2/Outter
const #23 = Asciz       com/cxh/test2/Outter;
const #24 = Asciz       Inner;
 
{
final com.cxh.test2.Outter this$0;
 
public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);
  Code:
   Stack=2, Locals=2, Args_size=2
   0:   aload_0
   1:   aload_1
   2:   putfield        #10; //Field this$0:Lcom/cxh/test2/Outter;
   5:   aload_0
   6:   invokespecial   #12; //Method java/lang/Object."<init>":()V
   9:   return
  LineNumberTable:
   line 16: 0
   line 18: 9
 
  LocalVariableTable:
   Start  Length  Slot  Name   Signature
   0      10      0    this       Lcom/cxh/test2/Outter$Inner;
 
 
}

 第11行~35行是常量池的内容，这里需要注意的是第38行的内容：

final com.cxh.test2.Outter this$0;

　　这行是一个指向外部类对象的指针，看到这里想必大家豁然开朗了。也就是说编译器会默认为成员内部类添加了一个指向外部类对象的引用，那么这个引用是如何赋初值的呢？下面接着看内部类的构造器：

public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);

　　从这里可以看出，虽然我们在定义的内部类的构造器是无参构造器，编译器还是会默认添加一个参数，该参数的类型为指向外部类对象的一个引用，所以成员内部类中的Outter this&0 指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。从这里也间接说明了成员内部类是依赖于外部类的，如果没有创建外部类的对象，则无法对Outter this&0引用进行初始化赋值，也就无法创建成员内部类的对象了。

3.局部内部类和匿名内部类只能访问局部final变量

 关于这个问题，我们先来看一段代码：

/*
 * 局部内部类和匿名内部类只能访问局部final变量 
 */
public class InnerClass {

    public static void main(String[] args) {
        test(11);
    }
    
    public static void test(final int a ){
        final double b = 11.234;
        //定义一个匿名内部类
        new Thread(){
            public void run() {
                System.out.println(a);
                System.out.println(b);
            }
            
        }.start();
    }
}

编译后生成了两个文件，即匿名内部类单独生成一个文件：InnerClass$1.class

上段代码中，如果把变量a和b前面的任一个final去掉，这段代码都编译不过。我们可以考虑这样一个问题： 当test方法执行完毕之后，变量a的生命周期就结束了，而此时Thread对象的生命周期很可能还没有结束，那么在Thread的run方法中继续访问变量a就变成不可能了，但是又要实现这样的效果，怎么办呢？Java采用“复制”的方法来解决这个问题。

 详细介绍请参看：http://www.cnblogs.com/dolphin0520/p/3811445.html

4.静态内部类特殊的地方

• 静态内部类是不依赖于外部类的，也就说可以在不创建外部类对象的情况下创建内部类的对象。
• 静态内部类是不持有指向外部类对象的引用的，可以反编译静态内部类的class文件，发现是没有Outter this&0引用的。

三.内部类的作用和使用场景

 关于内部类的作用和使用场景，这里总结了以下两点：

• 每个内部类都能独立的继承一个（接口的）实现，所以无论外部类是否已经继承了某个（接口的）实现，对于内部类都没有影响。所以，内部类使得多重继承的解决方案变得完整
• 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏
• 其中，匿名内部类常用于事件监听和多线程程序

 

全文参考自：http://www.cnblogs.com/dolphin0520/p/3811445.html