核心提示：定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类提供更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中其他类访问。内部类可以声明public、protected、private等访问限制，可以声明为abstract的供其他内部类或外部类继承与扩展定义在一个类内部的类叫内部类，包含内部类的类称为外部类。内部类提供更好的封装，可以把内部类隐藏在外部类之内，不允许同一个包中其他类访问。内部类可以声明public、protected、private等访问限制，可以声明为abstract的供其他内部类或外部类继承与扩展，或者声明为static、final的，也可以实现特定的接口。static的内部类行为上象一个独立的类，非static在行为上类似类的属性或方法且禁止声明static的方法。内部类可以访问外部类的所有方法与属性，内部类被单成其外部类的成员，同一个类的成员之间可以相互访问。但外部类不能访问内部类的实现细节，如内部类的属性。static的内部类只能访问外部类的静态属性与方法。匿名内部类适合用于创建那些仅需要一次使用的类。
内部类被作为成员内部类定义，而且不是局部内部类。成员内部类是一种与属性、方法、构造器和初始化块相似的类成员；局部内部类和匿名内部类则不是类成员。成员内部类分为两种：静态内部类（使用static修饰）和非静态内部类，
当在非静态内部类的方法访问某个变量时，系统优先在该方法内查找是否在该名字的局部变量，如果存在改名字的局部变量，就是用改变量；如果不存在则到内部类所在的外部类中查找是否存在改名字的属性，如果存在就是用。如果不存在编译错误。
如外部类属性、内部类属性与内部类里方法的局部变量通明，则通过使用this,外部类类名.this作为限制类区分。
1.public cla DiscernVariable
2.{
3.private String prop = \"外部类属性\";
4.private cla InCla
5.{
6.private String prop = \"内部类属性\";
7.public void info()
8.{
9.String prop = \"局部变量\";
10.//通过 外部类类名.this.varName 访问外部类实例属性
11.System.out.println(\"外部类的属性值：\" + DiscernVariable.this.prop);
12.//通过 this.varName 访问外内部类实例的属性
13.System.out.println(\"内部类的属性值：\" + this.prop);
14.//直接访问局部变量
15.System.out.println(\"局部变量的属性值：\" + prop);
16.}
17.}
18.public void test()
19.{
20.InCla in = new InCla();
21.in.info();
22.}
23.public static void main(String[] args)
24.{
25.new DiscernVariable().test();
26.}
27.}
非静态内部类的成员可以访问外部类的private成员，但反过来不可以。非静态内部类成员只在非静态内部类范围内是可知的，并不能被外部类直接使用。如果外部类需要访问非静态内部类成员，则必须相示创建非静态内部类对象来调用访问其实例成员。
1.public cla Outer
2.{
3.private int outProp = 9;
4.cla Inner
5.{
6.private int inProp = 5;
7.public void aceOuterProp()
8.{
9.//内部类可以直接访问外部类的成员
10.System.out.println(\"外部类的outProp属性值:\" + outProp);
11.}
12.}
13.public void acceInnerProp()
14.{
15.//外部类不能直接访问内部类属性,下面代码出现编译错误
16.//System.out.println(\"内部类的inProp属性值:\" + inProp);
17.//如需访问内部类成员，必须显式创建内部类对象
18.System.out.println(\"内部类的inProp属性值:\" + new Inner().inProp);19.
20.}
21.public static void main(String[] args)
22.{
23.//执行下面代码，只创建了外部类对象，还未创建内部类对象
24.Outer out = new Outer();
25.}
26.}
外部类按常规的类访问方式使用内部类，唯一的差别是外部类可以访问内部类的所有方法与属性，包括私有方法与属性。如：
1.pinner p = new pinner();
2.p.index = 20;
3.p.Print();
4.---- 这种方式适合外部类的非static方法；
5.
6.pouter po = new pouter();
7.pinner pi = po.new pinner();
8.pi.index = 40;
9.pi.Print();
10.---- 这种方式适合外部类的static方法；
内部类类似外部类的属性，因此访问内部类对象时总是需要一个创建好的外部类对象。内部类对象通过‘外部类名.this.xxx’的形式访问外部类的属性与方法。如：
1.System.out.println(\"Print in inner Outer.index=\" + pouter.this.index);
2.System.out.println(\"Print in inner Inner.index=\" + this.index);
如果需要在其他类中访问内部类，可以使用：
(1)外部类提供创建内部类的方法供其他类使用。如：
1.// 外部类
2.pinner getInner()
3.{
4.return new pinner();
5.}
6.
7.// 其他类
8.pouter.pinner pi = po.getInner();
9.pi.Print();
(2)直接创建内部类的对象。如：
1.pouter po = new pouter();
2.pouter.pinner pi = po.new pinner();
3.pi.Print();
内部类可以声明在外部类的方法中或语句块中。如果内部类需要访问包含它的外部类方法或语句块的局部变量或参数，则该局部变量或参数必须是final的。外部类的其他方法、其他类无法访问声明在方法内部或块内部的内部类。
如果一个类继承内部类，则创建该类的对象时需提供一个外部类的对象作为构造方法的参数。如：
1.cla Car
2.{
3.cla Wheel
4.{
5.
6.}
7.}
8.
9.cla SuperWheel extends Car.Wheel
10.{
11.SuperWheel(Car car)
12.{
13.car.super();
14.}
15.
16.public static void main(String [] args)
17.{
18.Car car = new Car();
19.SuperWheel wl = new SuperWheel(car);
20.}
21.}
如果创建命名的内部类没有多少实际意义时，可以创建匿名的内部类。比如使用内部类实现接口的功能(如事件处理器、适配器等)，而功能的差异较大，需要根据实际的情况创建相应的内部类时，可以使用匿名内部类。简单的示例如下：
1.interface WebView
2.{
3.void doGet();
4.}
5.
6.cla A
7.{
8.WebView ShowName()
9.{
10.return new WebView()
11.{
12.void doGet()
13.{
14.System.out.println(\"Name\");
15.}
16.};
17.}
18.
19.WebView ShowCode()
20.{
21.return new WebView()
22.{
23.void doGet()
24.{
25.System.out.println(\"Code\");
26.}
27.};
28.}
29.}
最后，JAVA 内部类还有一个作用，那就是实现JAVA的多继承。JAVA本身是不允许多继承的，如果我们想一个类继承多个基类，就可以使用内部类。通过内部类分别继承一个基类，外部类创建内部类的对象，并使用内部类的方法，变相地实现了多继承。
