java中的闭包与回调

      闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建他的作用域，用过这个定义 可以看出内部类是面向对象的闭包 因为他不仅包含外围类对象的信息 还自动拥有一个指向此外围类对象的引用 在此作用域内 内部类有权操作所有的成员 包括private成员；

     

interface Incrementable
{
     void increment();
}



class Callee1 implements Incrementable
{
     private int i=0;
     public void increment()
     {
          i++;
          System.out.println(i);
     }
}

class MyIncrement
{
     void increment()
     {
          System.out.println("other increment");
     }
     static void f(MyIncrement mi)
     {
          mi.increment();
     }
}

class Callee2 extends MyIncrement
{
     private int i=0;
     private void incr()
     {
          i++;
          System.out.println(i);
     }

     private class Closure implements Incrementable  //内部类
     {
          public void increment()
          {
               incr();
          }
     }

     Incrementable getCallbackReference()
     {
          return new Closure();   //新建内部类
     }
}


class Caller
 {
      private Incrementable callbackRefference;
      Caller(Incrementable cbh)
      {
           callbackRefference = cbh;
      }
      void go()
      {
           callbackRefference.increment();//调用increment()方法
      }
 }

public class Callbacks
{
     public  static void main(String [] args)
     {
          Callee1 c1=new Callee1();
          Callee2 c2=new Callee2();
          MyIncrement.f(c2);
          Caller caller1 =new  Caller(c1);
          Caller caller2=new Caller(c2.getCallbackReference());//将内部类中的Closure赋给Caller
          caller1.go();
          caller1.go();
          caller2.go();
          caller2.go();
     }
}

 

输出

other increment
1
2
1
2

Callee2 继承字MyIncrement 后者已经有一个不同的increment（）方法并且与Incrementable接口期望的increment（）方法完全不相关 所以如果Callee2继承了MyIncrement 就不能为了Incrementable的用途而覆盖increment（）方法 于是这能使用内部类独立的实现Incrementable

内部类Closure实现了Incrementable 一提供一个放回Caller2的钩子 而且是一个安全的钩子 无论谁获得此Incrementbale的引用 都只能调用increment（） 除此之外没有其他功能