深入理解内部类
- 为什么成员内部类可以无条件地访问外部类成员？
成员内部类甚至可以访问private的外部类成员，那么这究竟是怎么实现的呢？下面通过字节码文件来一探究竟。下面是Outer.java的代码：
public class Outter {
private Inner inner = null;
public Outter() {
}
public Inner getInnerInstance() {
if(inner == null)
inner = new Inner();
return inner;
}
protected class Inner {
public Inner() {
}
}
}编译以后，我们知道内部类会单独称为一个class字节码文件，
反编译Outer$Inner.class得到以下信息：
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;
}从{}里面开始看，第一行是
final com.cxh.test2.Outter this$0;这行是一个指向外部类对象的指针，也就是说编译器会默认给内部类添加一个指向外部类对象的引用。那么这个reference是如何赋初值的呢？看内部类的构造器。
public com.cxh.test2.Outter$Inner(com.cxh.test2.Outter);从这里可以看出，虽然我们在定义的内部类的构造器是无参构造，但是编译器还是会默认添加一个参数（指向外部类对象的一个reference），所以成员内部类中的Outter this&0指针便指向了外部类对象，因此可以在成员内部类中随意访问外部类的成员。这里也间接说明成员内部类是依赖于外部类的，如果没有外部类对象，则无法对Outter this&0引用进行初始化，也就无法创建内部类对象了。
内部类的使用场景和好处
为什么要使用内部类？总结起来有以下四点：
- 每个内部类都能独立地继承一个接口的实现，多以无论外部类是否已经继承了某个接口的实现，对于内部类没有影响。内部类使得多继承的解决方案更加完善
- 方便将存在一定逻辑关系的类组织在一起，又可以对外界隐藏
- 方便写事件驱动程序
- 方便写线程代码
最重要的一点是内部类的存在使得java的多继承机制变得完善（thinking in java）
常见的内部类相关面试题
- 根据注释在（1）（2）（3） 处填写代码
public class Test{
public static void main(String[] args){
// 初始化Bean1
(1)
bean1.I++;
// 初始化Bean2
(2)
bean2.J++;
//初始化Bean3
(3)
bean3.k++;
}
class Bean1{
public int I = 0;
}
static class Bean2{
public int J = 0;
}
}
class Bean{
class Bean3{
public int k = 0;
}
}由前面克制，对于成员内部类，必须先产生外部类的实例化对象，才能产生内部类的实例化对象，而静态内部类不用产生外部类对象就可以产生内部类的实例化对象。
创建静态内部类实例化对象的一般形式为：外部类类名.内部类类名 xxx = new 外部类类名.内部类类名（）
创建成员内部类实例化对象的一般形式为：外部类类名.内部类类名 xxx = 外部类对象名.new 内部类类名（）
因此，首先创建外部类对象，123处的代码分别是：
Test test = new Test();
Test.Bean1 bean1 = test.new Bean1();
Test.Bean2 b2 = new Test.Bean2(); - 下面这段代码的输出结果是什么？
public class Test {
public static void main(String[] args) {
Outter outter = new Outter();
outter.new Inner().print();
}
}
class Outter
{
private int a = 1;
class Inner {
private int a = 2;
public void print() {
int a = 3;
System.out.println("局部变量：" + a);
System.out.println("内部类变量：" + this.a);
System.out.println("外部类变量：" + Outter.this.a);
}
}
}结果：
3
2
1最后补充一点知识：关于成员内部类的继承问题。一般来说，内部类是很少用来作为继承用的。但是当用来继承的话，要注意两点：
1）成员内部类的引用方式必须为 Outter.Inner.
2）构造器中必须有指向外部类对象的引用，并通过这个引用调用super()。这段代码摘自《Java编程思想》
class WithInner {
class Inner{
}
}
class InheritInner extends WithInner.Inner {
// InheritInner() 是不能通过编译的，一定要加上形参
InheritInner(WithInner wi) {
wi.super(); //必须有这句调用
}
public static void main(String[] args) {
WithInner wi = new WithInner();
InheritInner obj = new InheritInner(wi);
}
}