内部类就是一种链关系，就好像C++当中的指针一样，或者这是一个指向具体内容的指针，或者这是一个指向指针的指针，看看下面的代码:class Outer1{ class Inner11{ class Inner111{ int var111 = 100; } } class Inner12{ class Inner121{ int var121 = 10; class Inner1211{ int var1211 = Outer1.Inner12.Inner121.this.var121; } } }}
public class OutClass1{ public static void main(String[] args){ int var1 = new Outer1().new Inner11().new Inner111().var111; int var2 = new Outer1().new Inner12().new Inner121().new Inner1211().var1211; System.out.println(var1); System.out.println(var2); }}这里的内部类嵌套了内部类，一层层的，很容易看出来就好像一种链接关系，就好像数据结构当中的树，层次分明。要注意的一个地方就是关于var1211的赋值，首先要说的就是要
找到上一级的变量，只要逐层找就可以了，还有就是因为上一层变量在赋值的时候要加上this.var121，因为要赋值的是上一层变量的实例变量。而this的使用则是，this放在哪个
类后，就说明该this是该类的实例。如果内部类是static的，那么就不需要这样一层一层的new了，它的使用方法，就好像普通的static一样，如果是逐层的static，那么要到最里层的静态变量，就好像普通的静态变
量一样，只不过多了一些指向的标识符而已。如果静态变量中间夹杂了非静态变量，那么该new的时候，就实例化，该直接用的时候，就直接用就可以了。
内部类的继承要调用父类的外层类的super()，下面看一下下面的代码:class Outer2{ class Inner21{ }}
class Outer3{ class Inner31 extends Outer2.Inner21{ Inner31(Outer2 o2){ o2.super(); } }}试试把构造函数注释掉，或者只注释o2.super()，看看是否能编译过去。
内部类可以使用外层类，但是，如果需要生成一个实例才有内部类，就不能通过编译了。也可以这样说，内部类可以写在外部类的函数中，但是，如果写到函数中，就不能在外层
类使用了，下面看一个例子:class Outer3{ void prtOuter3(){ System.out.println("Outer3"); } class Inner31{ Inner31(){ class Inner311{ void prtInner31(){ System.out.println("Inner311"); } void prtprtInner31(){ Outer3.this.prtOuter3(); } } } }}
public class OuterClass3{ public static void main(String[] args){ Outer3.Inner31.Inner311 inner = new Outer3().new Inner31().new Inner311(); inner.prtprtInner31(); }}上面这段代码是不能通过编译的，就是因为它把内部类写到了外层类的函数中之后，还想在外部使用它，想要通过编译(这里说的只是通过编译，没有说使用的意图)，有两个方法
可以，一个是将内部类移到构造方法外，另外一个就是不要在main方法当中实例该内部类。
又是外层，又是同层，又是内部类，写着写着万一重名了字母办(只是假设，很少有机会写这么多内部类，还有内部类嵌套内部类吧，如果出现这样的情况，首先要想的应该是，我
的设计是不是有问题？)？那么到底该调用哪个类呢，通过下面的例子，就能说明这样的情况。class Outer4{ { new Inner42(); } class Inner41{ { System.out.println("Outer4.Inner41"); } } class Inner42{ { new Inner41(); } class Inner41{ { System.out.println("Outer4.Inner42.Inner41"); } } }}
public class OuterClass4{ public static void main(String[] args){ new Outer4(); }}这时候出现了两个同名的类，一个是Inner42的内部类Inner41，一个是它的同级别的类，那么这时候要在Inner42里面实例化Inner41，会出现什么样的结果呢，是不会通过编译，
还是什么，运行一下，可以通过编译，得出的是Outer4.Inner42.Inner41，所以得出结论，如果同名，内部类优先，那么如果我想使用的是同级类呢，这也很简单，加上前面讲的
链new Outer4.Inner41()就可以了。所以也可以看出来，在链接的过程，不要出现同名，也就是说内部类的名字可以与该类的同级别类同名，但是不能在该链上出现同名。比如:class Outer{ class Inner1{ class Inner11{ //class Outer{}如果去掉注释就会出错 } }}这时候就不允许出现重名。
下面就是包含了一个内部类，内部接口，匿名类的例子，首先要说明的是，匿名内部类不像内部类那样，可以有构造函数，它不能有构造函数，所以只能通过块{}来初始化:interface OuterInterface{ int varInterface = 1; void pt();}
class Outer51{ Outer51(){ } int get(){ return 100; }}
class Outer52{ /*interface OuterInterface{ void pt(); }*/ class Inner521{ OuterInterface testMthodInterface(){ final int i = 2; int j = 3; return new OuterInterface(){ int k; { k = i+k; } public void pt(){ System.out.println(k); } }; } Outer51 testMethodClass(){ return new Outer51(){ public int get(){ return super.get()*10; } }; } }}
public class OuterClass5{ public static void main(String[] args){ int v1 = new Outer52().new Inner521().testMethodClass().get(); System.out.println(v1); new Outer52().new Inner521().testMthodInterface().pt(); }}从这里，就可以看出，继承接口内部优先。匿名内部类同普通类一样，可以继承自接口，也可以继承自类，继承自类的构造函数中，可以有参数。
接口可以嵌套在接口中，也可以嵌套在类的顶层中，但是不能嵌套在内部类中，看一下下面的代码:class OuterClass{ interface InnerInterface{} class InnerClass{ //interface InnerInterface{} }}如果去掉注释，就不能通过编译了。
ps:看到一篇关于内部类的总结(http://www.newasp.net/tech/java/14908.html)，觉得总结的不错，揣摩了一下，用自己的话总结了一下。
