JavaSE基础知识(二十)--Java内部类之闭包与回调(利用内部类去实现一个接口)

Java SE 是什么，包括哪些内容(二十)？

本文内容参考自Java8标准
再次感谢Java编程思想对本文的启发！
闭包是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域(内部类就是一个闭包，创建它的作用域就是外部类的作用域)。
通过之前有关内部类博文的描述，结合上面闭包的定义，我们可以知道：**内部类就是面向对象的闭包。**因为它不仅包含外部类对象的信息，还自动拥有一个指向此外部类对象的引用，在内部类里，它有权操作所有的外部类成员(还包括它自己的成员)，包括private成员。
Java最引人争议的问题之一就是，人们认为Java应该包含某种类似指针的机制，以允许回调(callback)。通过回调，对象能够携带一些信息，这些信息允许它在稍后的某个时候调用初始的对象。稍后将会看到这是一个非常有用的概念。如果回调是用过指针实现的，那么就只能寄希望于程序员不会误用指针。然而，我们已经了解到，Java更小心仔细，所以没有在语言中包括指针。
通过内部类提供闭包的功能是优良的解决方案，它比指针更灵活，更安全。
代码示例：

// 通过内部类实现闭包的功能
   //接口Incrementable
   interface Incrementable{
      //方法increment
      void increment();
   }
   //类Callee1实现接口Incrementable
   class Callee1 implements Incrementable{
      //int类型的类变量i,初始化为0
      private int i = 0;
      //方法increment()
      public void increment(){
         //每次调用方法,i值都自增1
         i++;
         //打印i值
         System.out.println(i);
      }
   }
   //类MyIncrement
   class MyIncrement{
      //方法increment()
      public void increment(){
         //打印字符串"Other operation"
         System.out.println("Other operation");
      }
      //static方法f(MyIncrement mi),带一个MyIncrement类型的
      //形式参数mi
      static void f(MyIncrement mi){
         //调用类MyIncrement的方法increment();
         mi.increment();
      }
   }
   //类Callee2继承类MyIncrement
   class Callee2 extends MyIncrement{
      //int类型的类变量i,初始化为0
      private int i = 0;
      //方法increment()
      public void increment(){
         //通过super关键字明确调用父类MyIncrement中的方法increment()
         super.increment();
         //每次调用方法,i值都自增1
         i++;
         //打印i值
         System.out.println(i);
      }
      //private内部类Closure实现接口Incrementable
      private class Closure implements Incrementable{
         //方法increment()
         public void increment(){
            //明确通过Callee2.this确定是调用外部类对象的方法increment(),
            //如果不这么声明,会造成无限递归,一个方法不断调用自己本身就是一个
            //无限递归
            Callee2.this.increment();
         }
      }
      //方法getCallbackReference(),返回类型为Incrementable
      Incrementable getCallbackReference(){
         //返回一个内部类Closure的对象实例,因为内部类Closure实现了接口
         //Incrementable,所以是合理的
         return new Closure();
      }
   }
   //类Caller
   class Caller{
      //组合了一个接口Incrementable类型的引用callbackReference
      private Incrementable callbackReference;
      //构造方法,带一个接口Incrementable类型的形式参数cbh
      Caller(Incrementable cbh){
         //为类变量callbackReference赋值
         callbackReference = cbh;
      }
      //方法go()
      void go(){
         //调用callbackReference的方法increment()
         //在这里引用callbackReference指向的是哪个类,就调用
         //哪个类的方法increment()(可能是Callee1或者Callee2)
         callbackReference.increment();
      }
   }
   //-------------------------------------
   //以上内容包括以下部分:
   //接口Incrementable
   //类Callee1,它实现了接口Incrementable
   //类MyIncrement
   //类Callee2,它继承了类MyIncrement,同时通过内部类Closure实现了接口Incrementable(闭包)
   //同时具有方法getCallbackReference()来回调内部类对象
   //类Caller,通过构造方法以及方法go()实现具体的回调功能
   //--------------------------------------
   //测试类Callbacks,测试回调功能
   public class Callbacks{
      //程序执行入口main方法
      public static void main(String[] args){
         //创建类Callee1的对象,通过c1引用
         Callee1 c1 = new Callee1();
         //创建类Callee2的对象,通过c2引用
         Callee2 c2 = new Callee2();
         //调用类Myincrement的static方法f(MyIncrement mi),将c2作为实际参数传入
         //实际上调用的是类Callee2的方法increment()
         //执行完这步后输出字符串"Other operation"(super.increment();)以及输出1
         MyIncrement.f(c2);
         //创建类Caller的对象,通过caller1引用,将c1作为实际参数传入它的构造方法
         Caller caller1 = new Caller(c1);
         //创建类Caller的对象,通过caller2引用,将c2.getCallbackReference()
         //作为实际参数传入它的构造方法(c2.getCallbackReference()实际返回的是内部类
         //Closure的对象实例).
         Caller caller2 = new Caller(c2.getCallbackReference());
         //调用方法go(),这时实际上调用的是类Callee1的increment()方法,输出1
         caller1.go();
         //调用方法go(),这时实际上调用的是类Callee1的increment()方法,输出2
         caller1.go();
         //调用方法go(),这时实际上调用的是内部类Closure的increment()方法,
         //先输出字符串"Other operation"(super.increment()),再输出2
         //为什么输出2呢?因为这行代码(MyIncrement.f(c2);)已经将c2引用的那个对象的i
         //值自增到了2.
         caller2.go();
         //调用方法go(),这时实际上调用的是内部类Closure的increment()方法,
         //先输出字符串"Other operation"(super.increment()),再输出3
         //为什么输出3呢?因为前面的方法go()已经将i值自增到了2.这里又调用了一次,就自增到了3.
         caller2.go();
      }
   }
   //所以最后的执行结果是
   //"Other operation"
   //1
   //1
   //2
   //"Other operation"
   //2
   //"Other operation"
   //3
   //所以你能发现这个程序可以在需要的时候进行回调,然后按需处理i值.

上面的代码示例进一步展示了外部类实现一个接口与内部类实现此接口之间的区别。就代码而言，Callee1是简单的解决方式(直接implements接口Incrementable)。Callee2继承类MyIncrement，但是类MyIncrement已经有了一个不同的方法increment()，并且与Incrementable接口期望的方法increment()完全不相关。在类Callee2继承了类MyIncrement的前提下就不能为了接口Incrementable的用途去覆盖方法increment()，于是只能使用内部类去独立地实现接口Incrementable(你需要注意的是，当创建一个内部类的时候，并没有在外围类的接口中添加任何东西，也没有修改外围类的接口)。
注意，在类Callee2中，除了方法getCallbackReference()以外，其他成员都是private的。要想建立与外部世界的任何连接，interface Incrementable都是必须的。在这里可以看到，interface是如何允许接口与接口的实现完全独立的(其实主要体现的是，无论是内部类还是外部类，都可以独立实现一个接口，一个内部类实现一个接口与外部类没有任何区别)。
内部类Closure实现了接口Incrementable，以提供一个返回类Callee2的"钩子"：
返回内部类的对象(钩子)，通过内部类的increment()方法明确去调用外部类Callee2的increment()方法(Callee2.this.increment())

它是一个安全的"钩子"，无论谁获得此Incrementable的引用，都只能调用方法increment()(因为只有方法increment())，除此之外没有其它的功能(不像指针那样，能做很多事情)。
类Caller的构造方法需要一个Incrementable类型的引用作为参数(可以在任意时刻捕获回调引用)，然后在以后的某个时刻，Caller对象可以使用此引用回调Callee类。
回调的价值在于它的灵活性，可以在运行时动态决定需要调用什么方法(比如在上面的内部类Closure中明确规定了调用方法increment())。在后面的博文中你会看到，在GUI中到处都使用了回调。
PS：时间有限，有关Java SE的内容会持续更新！今天就先写这么多，如果有疑问或者有兴趣，可以加QQ：2649160693，并注明CSDN，我会就博文中有疑义的问题做出解答。同时希望博文中不正确的地方各位加以指正。