网上看到一个贴子：http://topic.csdn.net/u/20080728/20/d60f719a-c103-44b8-8d0c-bc1c818b768a.html
觉得蛮有意思，在学习的工程中又引申出不少东西，真有趣！！
定义在类中方法之外的内部类分为实例内部类和静态内部类.
实例内部类自动持有外部类的实例的引用，即可以访问外部类的所有变量；
静态内部类可以直接访问外部类的静态成员；
定义在方法中的内部类叫局部内部类，该类只能访问被final修饰的局部变量和参数
接口定义如下：
public void print();
}
例子1:
代码
int c=18;
public Super getInstance(){
int a=5;
final int b=6;
class Inner implements Super{
public void print() {
//局部内部类中访问本方法的局部变量
//内部类中访问成员变量
System.out.println(c);//正常
}
}
return new Inner();
}
public static void main(String[] args) {
Super s=new Test().getInstance();
s.print();
}
}
例子2:
对上面例子1的例子改变一下，从内部类->匿名内部类
匿名内部类既然叫匿名，那么名字对于该类来说已经不重要，因为该匿名类的实例本来就不打算给别的类使用或重复使用，仅限于类内部使用或使用一次，所以就不需要类名了，不过因为没有类名匿名内部类也就没有构造函数了。
在方法里面定义的局部内部类（不管是否匿名），它可无条件访问外部类的成员变量，但要访问方法的局部变量或参数，就要加final修饰符。
代码
int c=18;
public Super getInstance(){
int a=5;
final int b=6;
return new Super(){
public void print() {
//局部内部类中访问本方法的局部变量
System.out.println(a);//编译错误: 从内部类中访问局部变量 a；需要被声明为final
System.out.println(b);//正常
System.out.println(c);//正常
}
};
}
public static void main(String[] args) {
Super s=new Test().getInstance();
s.print();
}
}
例子3:
虽然匿名类没有构造函数，但仍然可以调用父类的构造函数，并进行初始化。
看了这个例子你会觉得不用内部类也可以实现相同的功能啊，不就是不满意父类的getI()实现而重写一下吗，写一个子类继承一下不就搞定啦，何必那么复杂呢。那么请看例子4.
代码
public static void main(String[] args) {
Ftest inner = new Ftest();
T t = inner.get(3);
System.out.println(t.getI());
}
}
class T {
private int i;
public T(int i) {
this.i = i;
}
public int getI() {
return i;
}
}
class Ftest {
public T get(int x) {
// 创建匿名内部类，调用父类的构造方法
return new T(x) {
@Override
public int getI() {
return super.getI() * 10;
}
};
}
}
例子4:
其实通过匿名类可以减少不少类的定义,并且也提高了不少灵活性，最典型的是spring中HibernateTemplate,它是依靠回调函数HibernateCallBack来实现其功能的(ps:回调实际就是一种事件触发模式，就象连环地雷一样，一旦触发一个，这个再触发另外一个，比如在HibernateTemplate.executeFind这个方法被执行时，希望同时执行其他方法，就需要回调。)
HibernateCallback接口有一方法doInHibernate(Session session)
代码
return this.getHibernateTemplate().executeFind(new HibernateCallback(){
public Object doInHibernate(Session session) throws HibernateException, SQLException {
return session.createCriteria("from Order").list();
}
}
);
}
在doInHibernate中获得了session就可以做很多操作了，但这些操作是不确定的，而唯一确定的是spring对事务的管理与实现，是编程式还是声明式，spring的作者知道怎么做，这在源码里面已经写好的。
通过回调，把不确定的实现交由用户（程序员）控制，把一成不变的东西（事务）进行封装，相当于一个模板。
其实回调也可以理解为一种对象间传递信息的方式，有a,b,c,....,d等对象其中a,b,c,......等复数个对象对d感兴趣，那么当d的状态改变时(事件发生)，d就调用一个方法来通知a,b,c等对象，而这个方法对于a,b,c,....,d等对象都是知道的，那么就可以抽象出一个接口，并使a,b,c,......等复数个对象实现之，而且由于d能够知道有谁关注自己，那么d肯定持有相关这些对象的引用的集合，遍历这个集合并且调用这个接口方法，就可以成功通知相关的对象，由于这些对象实现了这个接口中的方法，那么只要这个方法定义合理，就可以获得d对象的状态信息，从而进行特定的操作。另外一个对象能够被d所持有，那么该对象肯定要调用d的一个方法，把自己的引用存进d对象的关注对象集合中，那么调用这个方法就做注册。
仔细的分析一下例子4：new HibernateCallback()的实现就是构造出一个关注者，把传入executeFind相当于注册，调用executeFind相当于触发事件。