内部类简介

虽然Java是一门相对比较简单的编程语言，但是对于初学者， 还是有很多东西感觉云里雾里， 理解的不是很清晰。内部类就是一个经常让初学者感到迷惑的特性。 即使现在我自认为Java学的不错了， 但是依然不是很清楚。其中一个疑惑就是为什么内部类对象可以访问外部类对象中的成员（包括成员变量和成员方法）？ 早就想对内部类这个特性一探究竟了，今天终于抽出时间把它研究了一下。

内部类就是定义在一个类内部的类。定义在类内部的类有两种情况：一种是被static关键字修饰的， 叫做静态内部类， 另一种是不被static关键字修饰的， 就是普通内部类。 在下文中所提到的内部类都是指这种不被static关键字修饰的普通内部类。 静态内部类虽然也定义在外部类的里面， 但是它只是在形式上（写法上）和外部类有关系， 其实在逻辑上和外部类并没有直接的关系。而一般的内部类，不仅在形式上和外部类有关系（写在外部类的里面）， 在逻辑上也和外部类有联系。 这种逻辑上的关系可以总结为以下两点：

1 内部类对象的创建依赖于外部类对象；

2 内部类对象持有指向外部类对象的引用。

上边的第二条可以解释为什么在内部类中可以访问外部类的成员。就是因为内部类对象持有外部类对象的引用。但是我们不禁要问， 为什么会持有这个引用？ 接着向下看， 答案在后面。

通过反编译字节码获得答案

[java] view
plaincopy

1. public class Outer {  
2.     int outerField = 0;  
3.       
4.     class Inner{  
5.         void InnerMethod(){  
6.             int i = outerField;  
7.         }  
8.     }  
9. }  

该文件很简单， 就不用过多介绍了。 在外部类Outer中定义了内部类Inner， 并且在Inner的方法中访问了Outer的成员变量outerField。

[plain] view
plaincopy

1. javap -classpath . -v Outer$Inner  

-classpath .   说明在当前目录下寻找要反编译的class文件

[plain] view
plaincopy

1. javap -classpath . -v com.baidu.Outer$Inner  

 

[plain] view
plaincopy

1. {  
2.   final Outer this$0;  
3.     flags: ACC_FINAL, ACC_SYNTHETIC  
4.   
5.   
6.   Outer$Inner(Outer);  
7.     flags:  
8.     Code:  
9.       stack=2, locals=2, args_size=2  
10.          0: aload_0  
11.          1: aload_1  
12.          2: putfield      #10                 // Field this$0:LOuter;  
13.          5: aload_0  
14.          6: invokespecial #12                 // Method java/lang/Object."<init>":()V  
15.          9: return  
16.       LineNumberTable:  
17.         line 5: 0  
18.       LocalVariableTable:  
19.         Start  Length  Slot  Name   Signature  
20.                0      10     0  this   LOuter$Inner;  
21.   
22.   void InnerMethod();  
23.     flags:  
24.     Code:  
25.       stack=1, locals=2, args_size=1  
26.          0: aload_0  
27.          1: getfield      #10                 // Field this$0:LOuter;  
28.          4: getfield      #20                 // Field Outer.outerField:I  
29.          7: istore_1  
30.          8: return  
31.       LineNumberTable:  
32.         line 7: 0  
33.         line 8: 8  
34.       LocalVariableTable:  
35.         Start  Length  Slot  Name   Signature  
36.                0       9     0  this   LOuter$Inner;  
37.                8       1     1     i   I  
38. }  

[plain] view
plaincopy

1. final Outer this$0;  

[plain] view
plaincopy

1. Outer$Inner(Outer);  
2.   flags:  
3.   Code:  
4.     stack=2, locals=2, args_size=2  
5.        0: aload_0  
6.        1: aload_1  
7.        2: putfield      #10                 // Field this$0:LOuter;  
8.        5: aload_0  
9.        6: invokespecial #12                 // Method java/lang/Object."<init>":()V  
10.        9: return  
11.     LineNumberTable:  
12.       line 5: 0  
13.     LocalVariableTable:  
14.       Start  Length  Slot  Name   Signature  
15.              0      10     0  this   LOuter$Inner;  

我们知道， 如果在一个类中， 不声明构造方法的话， 编译器会默认添加一个无参数的构造方法。 但是这句话在这里就行不通了， 因为我们明明看到， 这个构造函数有一个构造方法， 并且类型为Outer。 所以说，编译器会为内部类的构造方法添加一个参数， 参数的类型就是外部类的类型。

[java] view
plaincopy

1. class Outer$Inner{  
2.     final Outer this$0;  
3.       
4.     public Outer$Inner(Outer outer){  
5.         this.this$0 = outer;  
6.         super();  
7.     }  
8. }  

[plain] view
plaincopy

1. void InnerMethod();  
2.   flags:  
3.   Code:  
4.     stack=1, locals=2, args_size=1  
5.        0: aload_0  
6.        1: getfield      #10                 // Field this$0:LOuter;  
7.        4: getfield      #20                 // Field Outer.outerField:I  
8.        7: istore_1  
9.        8: return  

getfield      #10                 // Field this$0:LOuter;

总结