Java中的闭包与回调

本是古典何须时尚 2022-07-15 08:59 137阅读 0赞

# [Java中的闭包与回调 ][Java_] #

标签： [ java][java][callback][][class][][javascript][][interface][][工作][Link 1]

2012-03-06 22:51  5155人阅读 [评论][Link 2](0) 收藏 [举报][Link 3]

本文章已收录于：

![category_icon.jpg][] 分类：

J2SE*（113）* ![arrow_triangle_20_down.jpg][] ![arrow_triangle_up.jpg][]

[作者同类文章][Link 4] *X*

闭包是可以包含自由（未绑定）变量的代码块；这些变量不是在这个代码块或者任何全局上下文中定义的，而是在定义代码块的环境中定义。“闭包”一词来源于以下两者的结合：要执行的代码块（由于自由变量的存在，相关变量引用没有释放）和为自由变量提供绑定的计算环境（作用域）。在 Scheme、Common Lisp、Smalltalk、Groovy、[JavaScript][]、Ruby 和 [ Python][Python] 等语言中都能找到对闭包不同程度的支持。

闭包的价值在于可以作为函数对象或者匿名函数，对于类型系统而言这就意味着不仅要表示数据还要表示代码。支持闭包的多数语言都将函数作为第一级对象，就是说这些函数可以存储到变量中、作为参数传递给其他函数，最重要的是能够被函数动态地创建和返回。

首先让我们先来看一下在Javascript中闭包(Closure)

> **\[javascript\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]
> 
> 1.  function a()\{  
> 2.    
> 3.  　var i=0;  
> 4.    
> 5.  　function b()\{  
> 6.    
> 7.  　alert(++i);  
> 8.    
> 9.  　\}  
> 10.   
> 11. 　return b;  
> 12.   
> 13. 　\}  
> 14.   
> 15. 　var c = a();  
> 16.   
> 17. 　c();  
> 
> ![save_snippets.png][]
> 
>     　function a(){
>     
>         　　var i=0;
>     
>         　　function b(){
>     
>         　　alert(++i);
>     
>         　　}
>     
>         　　return b;
>     
>         　　}
>     
>         　　var c = a();
>     
>         　　c();
> 
>   
>   
>

这段代码有两个特点：

1、函数b嵌套在函数a内部；

2、函数a返回函数b。

这样在执行完var c=a()后，变量c实际上是指向了函数b，再执行c()后就会弹出一个窗口显示i的值(第一次为1)。这段代码其实就创建了一个闭包，为什么？因为函数a外的变量c引用了函数a内的函数b，就是说：

当函数a的内部函数b被函数a外的一个变量引用的时候，就创建了一个闭包。

简而言之，闭包的作用就是在a执行完并返回后，闭包使得Javascript的垃圾回收机制GC不会收回a所占用的资源，因为a的内部函数b的执行需要依赖a中的变量。

在上面的例子中，由于闭包的存在使得函数a返回后，a中的i始终存在，这样每次执行c()，i都是自加1后alert出i的值。

那么我们来想象另一种情况，如果a返回的不是函数b，情况就完全不同了。因为a执行完后，b没有被返回给a的外界，只是被a所引用，而此时a也只会被b引用，因此函数a和b互相引用但又不被外界打扰(被外界引用)，函数a和b就会被GC回收。

闭包的应用场景

1、保护函数内的变量安全。以最开始的例子为例，函数a中i只有函数b才能访问，而无法通过其他途径访问到，因此保护了i的安全性。

2、在内存中维持一个变量。依然如前例，由于闭包，函数a中i的一直存在于内存中，因此每次执行c()，都会给i自加1。

以上两点是闭包最基本的应用场景，很多经典案例都源于此。

[Java][] 语言本身还没有正式支持闭包，但它却允许模拟闭包。可以使用匿名的内部类来实现闭包。可以理解为因为它不仅包含外围类对象(创建内部类的作用域)的信息，还自动拥有一个指向此外围类对象的引用，在此作用城内，内部类有权操作所有的成员，包括private成员。

回调函数（callback Function），顾名思义，用于回调的函数。回调函数只是一个功能片段，由用户按照回调函数调用约定来实现的一个函数。回调函数是一个工作流的一部分，由工作流来决定函数的调用（回调）时机。回调函数包含下面几个特性：

1、属于工作流的一个部分；

2、必须按照工作流指定的调用约定来申明（定义）；

3、他的调用时机由工作流决定，回调函数的实现者不能直接调用回调函数来实现工作流的功能；

回调机制是一种常见的设计模型，他把工作流内的某个功能，按照约定的接口暴露给外部使用者，为外部使用者提供数据，或要求外部使用者提供数据。

java回调机制：

软件模块之间总是存在着一定的接口，从调用方式上，可以把他们分为三类：同步调用、回调和异步调用。

同步调用：一种阻塞式调用，调用方要等待对方执行完毕才返回，它是一种单向调用；

回调：一种双向调用模式，也就是说，被调用方在接口被调用时也会调用对方的接口；

异步调用：一种类似消息或事件的机制，不过它的调用方向刚好相反，接口的服务在收到某种讯息或发生某种事件时，会主动通知客户方（即调用客户方的接口）。

回调和异步调用的关系非常紧密：使用回调来实现异步消息的注册，通过异步调用来实现消息的通知。

看下面的例子：

> **\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]
> 
> 1.  packagecallbackexample;  
> 2.    
> 3.  public interface ICallBack \{  
> 4.    
> 5.  public void postExec();//需要回调的方法  
> 6.    
> 7.   \}  
> 
> ![save_snippets.png][]
> 
>     packagecallbackexample;
>     
>         public interface ICallBack {
>     
>         public void postExec();//需要回调的方法
>     
>          }
> 
>   
>   
>

另外的一个类：

> **\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]
> 
> 1.  packagecallbackexample;  
> 2.    
> 3.  public class FooBar \{ //组合聚合原则  
> 4.    
> 5.  privateICallBackcallBack;  
> 6.    
> 7.  public void setCallBack(ICallBackcallBack)  
> 8.    
> 9.  \{ this.callBack = callBack; doSth(); \}  
> 10.   
> 11. public void doSth()  
> 12.   
> 13. \{ callBack.postExec(); \} \}  
> 
> ![save_snippets.png][]
> 
>     packagecallbackexample;
>     
>         public class FooBar { //组合聚合原则
>     
>         privateICallBackcallBack;
>     
>         public void setCallBack(ICallBackcallBack)
>     
>         { this.callBack = callBack; doSth(); }
>     
>         public void doSth()
>     
>         { callBack.postExec(); } }
> 
>   
>   
>

第二个类在[测试][Link 5]类里面，是一个匿名类：

**\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]

1.      packagecallbackexample;  
2.    
3.      public class Test \{  
4.    
5.      public static void main(String\[\] args)  
6.    
7.      \{ FooBar foo = new FooBar();  
8.    
9.      foo.setCallBack(new ICallBack() \{  
10.   
11.     public void postExec()   
12.   
13. \{ System.out.println("在Test类中实现但不能被Test的对象引用,而由FooBar对象调用"); \} \}); \} \}

![save_snippets.png][]

packagecallbackexample;
    
        public class Test {
    
        public static void main(String[] args)
    
        { FooBar foo = new FooBar();
    
        foo.setCallBack(new ICallBack() {
    
        public void postExec() 
    
    { System.out.println("在Test类中实现但不能被Test的对象引用,而由FooBar对象调用"); } }); } }

以上代码中：

1.两个类：匿名类和FooBar

2.匿名类实现接口ICallBack(在test测试的main方法中用匿名类的形式实现)

3.FooBar 拥有一个参数为ICallBack接口类型的函数setCallBack(ICallBacko)

4.匿名类运行时调用FooBar中setCallBack函数,以自身传入参数

5.FooBar已取得匿名类，就可以随时回调匿名类中所实现的ICallBack接口中的方法

首先回调方法的概念与“构造方法”的概念是不一样的，它不是指java中某个具有特殊意义或用途的方法。

称它为方法的“回调”更恰当一些，它是指方法的一种调用方式。任何一个被“回调”的方法，皆可称之为“回调方法”

方法的回调通常发生在“java接口”和“抽象类”的使用过程中。

假设有接口名为ICallBack其中有方法名为postExec()

有类Myclass实现了该接口，也就是一定实现了postExec()这个方法。现在有另一个类FooBar它有个方法setCallBack(ICallBackcallBack) ,并且setCallBack方法调用了callBack的postExec()方法。

如果现在，我们使用一个Myclass的实例myClass，将它作为参数带入到setCallBack(ICallBackcallBack)方法中，我们就说setCallBack(ICallBackcallBack)方法回调了myClass的postExec()方法。

Java最引人争议的问题之一就是，人们认为Java应该包含某种类似指针的机制，以允许回调(callback)。通过回调，对象能够携带一些信息，这些信息允许它在稍后的某个时刻调用初始的对象。

如果回调是通过指针实现的，那么就只能寄希望于程序员不会误用该指针。然而，您应该已经了解到，Java更小心仔细，所以没有在语言中包括指针。

通过内部类提供闭包的功能是优良的解决方案，它比指针更灵活、更安全。

再看下面的例子：

> **\[java\]** [ view plain][view plain] [ copy][view plain] [ print][view plain] [?][view plain]
> 
> 1.  // innerclasses/Callbacks.java  
> 2.    
> 3.  // Using inner classes for callbacks  
> 4.    
> 5.  packageinnerclasses  
> 6.    
> 7.     
> 8.    
> 9.  interfaceIncrementable \{  
> 10.   
> 11. void increment();  
> 12.   
> 13. \}  
> 14.   
> 15.    // Very simple to just implement the interface  
> 16.   
> 17. class Callee1 implements Incrementable \{  
> 18.   
> 19. private int i = 0;  
> 20.   
> 21. public void increment() \{  
> 22.   
> 23. i++;  
> 24.   
> 25. System.out.println(i);  
> 26.   
> 27.  \}  
> 28.   
> 29.  \}  
> 30.   
> 31.    
> 32.   
> 33. classMyIncrement \{  
> 34.   
> 35. public void increment() \{System.out.println("Other operation");\}  
> 36.   
> 37. static void f(MyIncrement mi) \{mi.increment();\}  
> 38.   
> 39. \}  
> 40.   
> 41.    
> 42.   
> 43.    
> 44.   
> 45. // If your class must implement increment() in  
> 46.   
> 47. // some other way, you must use an inner class:  
> 48.   
> 49. class Callee2 extends MyIncrement \{  
> 50.   
> 51. private int i=0;  
> 52.   
> 53. public void increment() \{  
> 54.   
> 55. super.increment();  
> 56.   
> 57. i++;  
> 58.   
> 59. System.out.println(i);  
> 60.   
> 61. \}  
> 62.   
> 63. private class Closure implements Incrementable \{  
> 64.   
> 65. public void increment() \{  
> 66.   
> 67.  // Specify outer-class method, otherwise  
> 68.   
> 69.  // you'd get an infinite recursion  
> 70.   
> 71. Callee2.this.increment();  
> 72.   
> 73.  \}  
> 74.   
> 75.  \}  
> 76.   
> 77. IncrementablegetCallbackReference() \{  
> 78.   
> 79. return new Closure();  
> 80.   
> 81. \}  
> 82.   
> 83.  \}  
> 84.   
> 85.    
> 86.   
> 87. class Caller \{  
> 88.   
> 89. privateIncrementablecallbackReference;  
> 90.   
> 91. Caller(Incrementablecbh) \{callbackReference = cbh;\}  
> 92.   
> 93. void go() \{callbackReference.increment();\}  
> 94.   
> 95. \}  
> 96.   
> 97.    
> 98.   
> 99. public class Callbacks \{  
> 100.   
> 101. public static void main(String\[\] args) \{  
> 102.   
> 103. Callee1 c1 = new Callee1();  
> 104.   
> 105.  Callee2 c2 = new Callee2();  
> 106.   
> 107. MyIncrement.f(c2);  
> 108.   
> 109.    
> 110.   
> 111. Caller caller1 = new Caller(c1);  
> 112.   
> 113. Caller caller2 = new Caller(c2.getCallbackReference());  
> 114.   
> 115. caller1.go();  
> 116.   
> 117. caller1.go();  
> 118.   
> 119. caller2.go();  
> 120.   
> 121. caller2.go();  
> 122.   
> 123.  \}  
> 124.   
> 125. \}  
> 
> ![save_snippets.png][]
> 
>     // innerclasses/Callbacks.java
>     
>     // Using inner classes for callbacks
>     
>     packageinnerclasses
>     
>      
>     
>     interfaceIncrementable {
>     
>     void increment();
>     
>     }
>     
>        // Very simple to just implement the interface
>     
>     class Callee1 implements Incrementable {
>     
>     private int i = 0;
>     
>     public void increment() {
>     
>     i++;
>     
>     System.out.println(i);
>     
>      }
>     
>      }
>     
>      
>     
>     classMyIncrement {
>     
>     public void increment() {System.out.println("Other operation");}
>     
>     static void f(MyIncrement mi) {mi.increment();}
>     
>     }
>     
>      
>     
>      
>     
>     // If your class must implement increment() in
>     
>     // some other way, you must use an inner class:
>     
>     class Callee2 extends MyIncrement {
>     
>     private int i=0;
>     
>     public void increment() {
>     
>     super.increment();
>     
>     i++;
>     
>     System.out.println(i);
>     
>     }
>     
>     private class Closure implements Incrementable {
>     
>     public void increment() {
>     
>      // Specify outer-class method, otherwise
>     
>      // you'd get an infinite recursion
>     
>     Callee2.this.increment();
>     
>      }
>     
>      }
>     
>     IncrementablegetCallbackReference() {
>     
>     return new Closure();
>     
>     }
>     
>      }
>     
>      
>     
>     class Caller {
>     
>     privateIncrementablecallbackReference;
>     
>     Caller(Incrementablecbh) {callbackReference = cbh;}
>     
>     void go() {callbackReference.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());
>     
>     caller1.go();
>     
>     caller1.go();
>     
>     caller2.go();
>     
>     caller2.go();
>     
>      }
>     
>     }
> 
>   
>   
> 
> 
> 输出：
> 
>  
> 
>  Other operation
> 
> 1
> 
> 1
> 
> 2
> 
> Other operation
> 
> 2
> 
> Other operation
> 
> 3

这个例子进一步展示了外围类实现一个接口与内部类实现此接口之间的区别。就代码而言，Callee1是简单的解决方式。Callee2继承自MyIncrement，后者已经有了一个不同的increment()方法，并且与Incrementable接口期望的increment()方法完全不相关。

所以如果Callee2继承了MyIncrement，就不能为了Incrementable的用途而覆盖increment()方法，于是只能使用内部类独立地实现Incrementable。还要注意，当创建了一个内部类时，并没有在外围类的接口中添加东西，也没有修改外围类的接口。

注意，在Callee2中除了getCallbackReference()以外，其他成员都是private的。要想建立与外部世界的任何连接，interface Incrementable都是必需的。在这里可以看到，interface是如何允许接口与接口的实现完全独立的。

内部类Closure实现了Incrementable，以提供一个返Callee2的“钩子”(hook)——而且是一个安全的钩子。无论谁获得此Incrementable的引用，都只能调用increment()，除此之外没有其他功能(不像指针那样，允许您做很多事情)。

Caller的构造器需要一个Incrementable的引用作为参数(虽然可以在任意时刻捕获回调引用)，然后在以后的某个时刻，(Caller对象可以使用此引用回调Callee类。

回调的价值在于它的灵活性——可以在运行时动态地决定需要调用什么方法。

http://blog.csdn[.NET][]/sharke118/article/details/6675005

顶

踩

*  上一篇[Java:使用内部类实现类的多重继承][Java 1]
 *  下一篇[JAVA中String.format的用法][JAVA_String.format]

#### 我的同类文章 ####

[Java_]: http://blog.csdn.net/yaerfeng/article/details/7326956
[java]: http://www.csdn.net/tag/java
[callback]: http://www.csdn.net/tag/callback
[class]: http://www.csdn.net/tag/class
[javascript]: http://www.csdn.net/tag/javascript
[interface]: http://www.csdn.net/tag/interface
[Link 1]: http://www.csdn.net/tag/%e5%b7%a5%e4%bd%9c
[Link 2]: http://blog.csdn.net/yaerfeng/article/details/7326956#comments
[Link 3]: http://blog.csdn.net/yaerfeng/article/details/7326956#report
[category_icon.jpg]: /images/20220715/c5dc988c134a4eff93ccefe5cc15e7e7.png
[arrow_triangle_20_down.jpg]: http://static.blog.csdn.net/images/arrow_triangle%20_down.jpg
[arrow_triangle_up.jpg]: /images/20220715/b2aa5c839d084726a246ea455e66f787.png
[Link 4]: http://blog.csdn.net/yaerfeng/article/category/1061660
[JavaScript]: http://lib.csdn.net/base/javascript
[Python]: http://lib.csdn.net/base/python
[view plain]: http://blog.csdn.net/yaerfeng/article/details/7326956#
[save_snippets.png]: /images/20220715/2fb801df2eff4e4eb9cd57fa88b5bd8a.png
[Java]: http://lib.csdn.net/base/javaee
[Link 5]: http://lib.csdn.net/base/softwaretest
[.NET]: http://lib.csdn.net/base/dotnet
[Java 1]: http://blog.csdn.net/yaerfeng/article/details/7326891
[JAVA_String.format]: http://blog.csdn.net/yaerfeng/article/details/7328092