内部类的定义是:定义在另一个类内部的类。
　　存在它的原因是:
　　1.一个内部类的对象能够访问创建它的对象的实现，包括私有数据。即内部类实例对包含它的那个类的实例来说，是特权的。
　　2.对于同一个包中的其他类来说,内部类能够隐藏起来,换句话说，内部类不管方法的可见性如何，那怕是public，除了包容类，其他类都无法使用它。
　　3.匿名内部类可以很方便的定义回调。
　　4.使用内部类可以非常方便的编写事件驱动程序。

其实它真正的目的仅仅为了定义回调－－进一步就是事件驱动。

接口和回调：编程一个常用的模式是回调模式,在这种模式中你可以指定当一个特定时间发生时回调对象上的方法。(看到后面click和线程回调就造了)

---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------

1.

public interface Contents {//接口1 
    int value(); 
} 
public interface Destination {//接口2 
    String readLabel(); 
} 
public class Goods { 
    private class Content implements Contents {//内部类1  private 
        private int i = 11; 
        public int value() { 
            return i; 
        } 
    } 
    protected class GDestination implements Destination {//内部类2  protected 
        private String label; 
        private GDestination(String whereTo) {//构造函数 
            label = whereTo; 
        } 
        public String readLabel() {//对外提供可访问内部属性的方法 
            return label; 
        } 
    } 
	//接口的类型指向实现接口的对象-------------多态的表现 
	//父类引用指向子类对象-------多态一般要有继承，重写，父类引用指向子类对象 
	//外部类的方法创建并返回内部类对象 
    public Destination dest(String s) {//Goods类的成员方法1 
        return new GDestination(s); 
    } 
    public Contents cont() {//Goods类的成员方法2 
        return new Content(); 
    } 
} 
class TestGoods { 
    public static void main(String[] args) { 
        Goods p = new Goods(); 
        Contents c = p.cont();				//利用外部类的方法创建并返回内部类对象 
        Destination d = p.dest("Beijing");	//利用外部类的方法创建并返回内部类对象 
    } 
}

在这个例子里类Content和GDestination被定义在了类Goods内部，并且分别有着protected和private修饰符来控制访问级别。
Content代表着Goods的内容，而GDestination代表着Goods的目的地。它们分别实现了两个接口Content和Destination。
在后面的main方法里，直接用Contents c和Destination d进行操作，你甚至连这两个内部类的名字都没有看见！
这样，
内部类的第一个好处就体现出来了—— 隐藏你不想让别人知道的操作，也即封装性 。
    同时，我们也发现了在外部类作用范围之外得到内部类对象的第一个方法，那就是利用其外部类的方法创建并返回。
上例中的cont()和dest()方法就是这么做的。那么还有没有别的方法呢？
当然有，其语法格式如下：

outerObject=new outerClass(Constructor Parameters); 
outerClass.innerClass innerObject=outerObject.new InnerClass(Constructor Parameters);

2.非静态内部类对象有着指向其外部类对象的引用

public class Goods { 
    private valueRate=2;// 
    private class Content implements Contents { 
        private int i = 11*valueRate;/// 
        public int value() { 
            return i; 
        } 
    } 
	xxxxxxxxxxxxxxxxx 
}

一个内部类对象可以访问创建它的外部类对象的内容， 甚至包括私有变量！

如果内部类里的一个成员变量与外部类的一个成员变量同名，也即外部类的同名成员变量被屏蔽了，怎么办？没事，Java里用如下格式表达外部类的引用：outerClass.this

3.静态内部类

a.和普通的类一样，内部类也可以有静态的。不过和非静态内部类相比，区别就在于静态内部类没有了指向外部的引用。这实际上和C++中的嵌套类很相像了，Java内部类与C++嵌套类最大的不同就在于是否有指向外部的引用这一点上，当然从设计的角度以及以它一些细节来讲还有区别。

b.在任何非静态内部类中，都不能有静态数据，静态方法或者又一个静态内部类（内部类的嵌套可以不止一层）。不过静态内部类中却可以拥有这一切。这也算是两者的第二个区别吧。

4.匿名内部类

//安卓里面的按钮的点击事件实现click接口 
btnBack.setOnClickListener(new OnClickListener() { 
			@Override 
			public void onClick(View v) { 
				finish(); 
			} 
		});

		//Runnable接口的匿名内部类实现 
		new Thread(new Runnable() { 
			@Override 
			public void run() { 
                 xxxxxx 
		}).start(); 
		// 声明一个子线程 
		//Thread类的匿名内部类实现 
		new Thread() { 
			@Override 
			public void run() { 
				xxxxxxxx 
			} 
		}.start();

匿名内部类也就是没有名字的内部类
正因为没有名字，所以匿名内部类只能使用一次，它通常用来简化代码编写

但使用匿名内部类还有个前提条件：必须继承一个父类或实现一个接口

匿名内部类由于没有名字，所以它没有构造函数

匿名内部类的两种实现方式：第一种，继承一个类，重写其方法；第二种，实现一个接口（可以是多个），实现其方法。