标签：
Java内部类含义：就是类中还包含了另外一个内，被包含的类叫内部类。
`就好比一个人是由大脑、肢体、器官等身体结果组成，而内部类相当于其中的某个器官之一，例如心脏：它也有自己的属性和行为（血液、跳动）。显然，此处不能单方面用属性或者方法表示一个心脏，因为心脏也有自己属性和方法，所以在人体中需要心脏这个内部类，正如同是内部类（心脏）在外部类（人体）当中。
内部类的共性：
1 //外部类 2 class Outer{ 3 private int age = 10; 4 //内部类 5 class Inner{ 6 //内部类中的内部方法 7 public void print(){ 8 System.out.println(age); 9 } 10 } 11 } 12 13 public class TestDebug10 { 14 public static void main(String[] args) { 15 Outer.Inner inner = new Outer().new Inner(); 16 inner.print(); 17 //或者采用一下方式访问内部类 18 /* 19 Outer outer = new Outer(); 20 Outer.Inner inner = outer.new Inner(); 21 inner.print(); 22 */ 23 } 24 25 }
运行结果：
10
此时我们要问，为什么要使用内部类，直接定义两个独立的类不就OK了吗？
因为内部类可以随意使用外部类的成员变量（包括私有）而不用生成外部类的对象，这也是内部类的唯一优点，如同心脏可以直接访问身体的血液，而不是通过医生来抽血。而且内部类继承自某个类或实现某个接口，内部类的代码操作创建其的外围类的对象。所以你可以认为内部类提供了某种进入其外围类的窗口。
使用内部类最吸引人的原因是：每个内部类都能独立地继承自一个（接口的）实现，所以无论外围类是否已经继承了某个（接口的）实现，对于内部类都没有影响。如果没有内部类提供的可以继承多个具体的或抽象的类的能力，一些设计与编程问题就很难解决。从这个角度看，内部类使得多重继承的解决方案变得完整。接口解决了部分问题，而内部类有效地实现了“多重继承”。
程序编译过后会产生两个.class文件，分别是Outer.class和Outer$Inner.class
Outer.Inner inner = new Outer().new Inner();这个实例化是用来生成内部类的对象，这种方法存在两个小知识点需要注意
1.开头的Outer是为了标明需要生成的内部类对象在outer这个外部类当中
2.必须先有外部类的对象才能生成内部类的对象，因为内部类的作用就是为了访问外部类中的成员变量
1 //外部类 2 class Outer{ 3 private int age = 10; 4 //内部类 5 class Inner{ 6 //内部类中的成员变量 7 private int age = 11; 8 //内部类中的内部方法 9 public void print(){ 10 //局部变量 11 int age = 12; 12 System.out.println("局部变量"+age); 13 System.out.println("内部类变量"+this.age); 14 System.out.println("外部类变量"+Outer.this.age); 15 } 16 } 17 } 18 19 public class TestDebug10 { 20 public static void main(String[] args) { 21 Outer.Inner inner = new Outer().new Inner(); 22 inner.print(); 23 } 24 25 }
运行结果：
局部变量12
内部类变量11
外部类变量10
从知识点1中可以发现，内部类在没有同名成员变量和局部变量的情况下，内部类会直接访问外部类的成员变量，而无需指定Out.this.属性名。否则，内部类中的局部变量会覆盖外部类的成员变量。从知识点2可以发现，访问内部类本身的成员变量可用this.属性名，访问外部类的成员变量需要使用Out.this.属性名。
1 //外部类 2 class Outer{ 3 private static int age = 10; 4 private int age2 = 11; 5 //内部类 6 static class Inner{ 7 //内部类中的内部方法 8 public void print(){ 9 System.out.println(age); 10 // System.out.println(age2); //语法错误，不能对非静态字段 age2 进行静态引用 11 } 12 } 13 } 14 15 public class TestDebug10 { 16 public static void main(String[] args) { 17 Outer.Inner inner = new Outer.Inner(); //此时的实例化方法不同于非静态的内部类 18 inner.print(); 19 } 20 21 }
运行结果：
10
可以看到，如果用static 将内部内静态化，那么内部类就只能访问外部类的静态成员变量，具有局限性其次，因为内部类被静态化，因此Out.In可以当做一个整体看，可以直接new 出内部类的对象（通过类名访问static，生不生成外部类对象都没关系）
1 //外部类 2 class Outer{ 3 private static int age = 10; 4 //内部类 5 private class Inner{ 6 //内部类中的内部方法 7 public void print(){ 8 System.out.println(age); 9 } 10 } 11 public void outerprint(){ 12 new Inner().print(); 13 } 14 } 15 16 public class TestDebug10 { 17 public static void main(String[] args) { 18 /* // 访问私有的内部类的时候此种方法错误 19 Outer.Inner inner = new Outer.Inner(); //此时的实例化方法不同于非静态的内部类 20 inner.print(); 21 */ 22 Outer outer = new Outer(); 23 outer.outerprint(); 24 } 25 26 }
运行结果：
10
如果一个内部类只希望被外部类中的方法操作，那么可以使用private声明内部类，上面的代码中，我们必须在Out类里面生成In类的对象进行操作，
而无法再使用Out.In in = new Out().new In() 生成内部类的对象，也就是说，此时的内部类只有外部类可控制。如同是，我的心脏只能由我的身体控制，
其他人无法直接访问它。
1 //外部类 2 class Outer{ 3 private static int age = 10; 4 public void Print(final int x){ 5 class Inner{ 6 public void InnerPrint(){ 7 System.out.println(x); 8 System.out.println(age); 9 } 10 } 11 new Inner().InnerPrint(); 12 } 13 } 14 15 public class TestDebug10 { 16 public static void main(String[] args) { 17 Outer outer = new Outer(); 18 outer.Print(11); 19 } 20 21 }
运行结果：
11 10
在上面的代码中，我们将内部类移到了外部类的方法中，然后在外部类的方法中再生成一个内部类对象去调用内部类方法，如果此时我们需要往外部类的方法中传入参数，
那么外部类的方法形参必须使用final定义。至于final在这里并没有特殊含义，只是一种表示形式而已。
标签：
原文地址：http://www.cnblogs.com/zicheng789/p/4656874.html
