一个贴子引发的对回调的思考

网上看到一个贴子：http://topic.csdn.net/u/20080728/20/d60f719a-c103-44b8-8d0c-bc1c818b768a.html

觉得蛮有意思，在学习的工程中又引申出不少东西，真有趣！！

 

定义在类中方法之外的内部类分为实例内部类和静态内部类.

实例内部类自动持有外部类的实例的引用，即可以访问外部类的所有变量；

静态内部类可以直接访问外部类的静态成员；

定义在方法中的内部类叫局部内部类，该类只能访问被final修饰的局部变量和参数

 

接口定义如下：

 

interface Super{
    public void print();
}

 

例子1:

 

public class Test {
    int c=18;
    public Super getInstance(){
        int a=5;
        final int b=6;
        class Inner implements Super{
            public void print() {
              　//局部内部类中访问本方法的局部变量
                System.out.println(a);//编译错误: 从内部类中访问局部变量 a；需要被声明为final
                //内部类中访问成员变量
　　　　　　　　　System.out.println(b);//正常
                System.out.println(c);//正常
            }            
        }
        return new Inner();        
    }
    public static void main(String[] args) {
        Super s=new Test().getInstance();
        s.print();
    }
}

 

 例子2:

对上面例子1的例子改变一下，从内部类->匿名内部类

匿名内部类既然叫匿名，那么名字对于该类来说已经不重要，因为该匿名类的实例本来就不打算给别的类使用或重复使用，仅限于类内部使用或使用一次，所以就不需要类名了，不过因为没有类名匿名内部类也就没有构造函数了。

在方法里面定义的局部内部类（不管是否匿名），它可无条件访问外部类的成员变量，但要访问方法的局部变量或参数，就要加final修饰符。

public class Test {
    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 class Test3 {
    
    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)

public List<OrderInfo> getAllOrderInfo() {        
               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相当于触发事件。