所谓内部类(Inner Class)，顾名思义，就是指定义在另外一个类中的类。因为安全机制的原因，内部类通常声明为private类别，因此，只有在内部类所在的外部中才能够创建内部类的对象，对其它类而言它是隐藏的。
内部类的分类：
（1）、 定义在方法体外的成员内部类
（2）、定义在方法体内部的内部类。该类又分为：一、有实例名称的内部类；二、无实例 名称的内部类。
使用内部类的主要原因：
1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。即内部类实例对包含它的那个类的实例来说，是特权的。
2.对于同一个包中的其他类来说,内部类能够隐藏起来,换句话说，内部类不管方法的可见性如何，那怕是public，除了包容类，其他类都无法使用它。
3.匿名内部类可以很方便的定义回调。
4.使用内部类可以非常方便的编写事件驱动程序。
其实它真正的目的仅仅为了定义回调－－进一步就是事件驱动。
接口和回调：编程一个常用的模式是回调模式,在这种模式中你可以指定当一个特定时间发生时回调对象上的方法
内部类的使用：
(1)、对于定义在方法体外的内部类（成员内部类）
* 定义在方法体外的成员内部类，可以通过外部类的实例来引用，语法格式为：
new 外部类构造方法().new 内部类构造方法();
外部类对象实例.new 内部类构造方法();
* 静态内部类的引用：
静态内部类附属外部类，而不附属于外部类的实例，因此不需要通过外部类的对象实例来创建内部类对象，直接通过外部类名就可以实现。语法为：new 外部类.内部类构造方法();
(2) 对于定义在方法体内的内部类。
由于附属于方法体，所以只能在方法体中创建实例对象，并且创建的实例也只能在方法体中被访问。所创建的对象实例的生命周期与方法相同，当方法结束后，对象也就随之消失。
匿名内部类
匿名内部，就是在java类中创建的类没有名字的内部类。有一点需要注意的是，匿名内部类由于没有名字，所以它没有构造函数（但是如果这个匿名内部类继承了一个只含有带参数构造函数的父类，创建它的时候必须带上这些参数，并在实现的过程中使用super关键字调用相应的内容）。如果你想要初始化它的成员变量，有下面几种方法：
1. 如果是在一个方法的匿名内部类，可以利用这个方法传进你想要的参数，不过记住，这些参数必须被声明为final。
2. 将匿名内部类改造成有名字的局部内部类，这样它就可以拥有构造函数了。
3. 在这个匿名内部类中使用初始化代码块。
（转） 匿名类和内部类中的中的this :
有时候，我们会用到一些内部类和匿名类。当在匿名类中用this时，这个this则指的是匿名类或内部类本身。
这时如果我们要使用外部类的方法和变量的话，则应该加上外部类的类名。如下面这个例子：
public class A {
int i = 1;
public A() {
Thread thread = new Thread() {
public void run() {
for(;;) {
A.this.run();
try {
sleep(1000);
} catch(InterruptedException ie) {
}
}
}
};
thread.start();
}
public void run() {
System.out.println("i = " + i);
i++;
}
public static void main(String[] args) throws Exception {
new A();
}
}
在上面这个例子中, thread 是一个匿名类对象，在它的定义中，它的 run 函数里用到了外部类的 run 函数。
这时由于函数同名，直接调用就不行了。这时有两种办法，一种就是把外部的 run 函数换一个名字，但这种办法对于一个开发到中途的应用来说是不可取的
。那么就可以用这个例子中的办法用外部类的类名加上 this 引用来说明要调用的是外部类的方法 run。
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
对于这个例子：
this.test(new Inner(){
public void method1(){
System.out.print("1111");
}
public void method2(){
System.out.print("22222");
}
});
这个时候调用test()方法，那Inner类的method1和method2是什么时候被调用的？难道也是this对象向他们发消息（比如传入一个参数）吗？还是直接显式的调用？？
对于Inner类，除了this这个类，就是this.test(...那句中的this，它能够调用Inner类的方法，其他地方都不行，然而，这也需要你在类中有个地方保存有对这个内部类实例的引用才可以。再说明一次，内部类是用来在某个时刻调用外面的方法而存在的－－这就是回调。
为了说明内部类实例的方法只能在包容类的实例中调用，其他地方无法调用，给个例子如下：
JAVA2实用教程源码：
/** 一个应用程序，用来演示内部类的使用 */
/** 类Outer */
class Outer{
private static int size;
/** 内部类Inner的声明 */
public class Inner{
private int size;
/** 方法doStuff() */
public void doStuff(int size){
size++; //存取局部变量
this.size++; //存取其内部类的成员变量
Outer.this.size++; //存取其外部类的成员变量
System.out.println(size+" "+this.size+" "+Outer.this.size);
}
}//内部类Inner结束
/** 类Outer中定义的实例方法testInner()方法 */
public void testInner(){
Inner i=new Inner();
i.doStuff(5);
}
/** main()方法 */
public static void main(String[] a){
Outer o=new Outer();
o.testInner();
}
}//类Outer结束
－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－－
那么，如何使用内部类,匿名类实现事件处理呢？
JAVA---事件适配器
1．事件适配器--EventAdapter
下例中采用了鼠标适配器：
import java.awt.*;
import java.awt.event.*;
public class MouseClickHandler extends MouseAdaper{
public void mouseClicked(MouseEvent e) //只实现需要的方法
{ ……}
}
java.awt.event包中定义的事件适配器类包括以下几个：
1．ComponentAdapter( 组件适配器)
2．ContainerAdapter( 容器适配器)
3．FocusAdapter( 焦点适配器)
4．KeyAdapter( 键盘适配器)
5．MouseAdapter( 鼠标适配器)
6．MouseMotionAdapter( 鼠标运动适配器)
7．WindowAdapter( 窗口适配器)
2. 用内部类实现事件处理
内部类（inner class）是被定义于另一个类中的类，使用内部类的主要原因是由于：
◇ 一个内部类的对象可访问外部类的成员方法和变量，包括私有的成员。
◇ 实现事件监听器时，采用内部类、匿名类编程非常容易实现其功能。
◇ 编写事件驱动程序，内部类很方便。
因此内部类所能够应用的地方往往是在AWT的事件处理机制中。
例5.11
import java.awt.* ;
import java.awt.event.*；
public class InnerClass{
private Frame f;
private TextField tf;
public InnerClass(){
f=new Frame("Inner classes example");
tf=new TextField(30);
}
public voidi launchFrame(){
Label label=new Label("Click and drag the mouse");
f.add(label,BorderLayout.NORTH);
f.add(tf,BorderLayout.SOUTH);
f.addMouseMotionListener(new MyMouseMotionListener());/*参数为内部类对象*/
f.setSize(300,200);
f.setVisible(true);
}
class MyMouseMotionListener extends MouseMotionAdapter{ /*内部类开始*/
public void mouseDragged(MouseEvent e) {
String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
tf.setText(s); }
} ;
public static void main(String args[]) {
InnerClass obj=new InnerClass();
obj.launchFrame();
}
}//内部类结束
}
3．匿名类（Anonymous Class）
当一个内部类的类声名只是在创建此类对象时用了一次，而且要产生的新类需继承于一个已有的父类或实现一个接口，才能考虑用匿名类，由于匿名类本身无名，因此它也就不存在构造方法，它需要显示地调用一个无参的父
类的构造方法，并且重写父类的方法。所谓的匿名就是该类连名字都没有，只是显示地调用一个无参的父类的构造方法。
例5.12
import java.awt.* ;
import java.awt.event.*;
public class AnonymousClass{
private Frame f;
private TextField tf;
public AnonymousClass(){
f=new Frame("Inner classes example");
tf=new TextField(30);
}
public void launchFrame(){
Label label=new Label("Click and drag the mouse");
f.add(label,BorderLayout.NORTH);
f.add(tf,BorderLayout.SOUTH);
f.addMouseMotionListener(new MouseMotionAdapter(){ //匿名类开始
public void mouseDragged(MouseEvent e){
String s="Mouse dragging: x="+e.getX()+"Y="+e.getY();
tf.setText(s); }
} ); //匿名类结束
f.setSize(300,200);
f.setVisible(true);
}
public static void main(String args[]) {
AnonymousClass obj=new AnonymousClass();
obj.launchFrame();
}
}
其实仔细分析，例5.11和5.12实现的都是完全一样的功能，只不过采取的方式不同。5.11中的事件处理类是一个内部类，而5.12的事件处理类是匿名类，可以说从类的关系来说是越来越不清楚，但
是程序也越来越简练。熟悉这两种方式也十分有助于编写图形界面的程序。
亲自在IDE中实践一下，会理解的更深切一点。