### [闭包与回调](https://lingcoder.gitee.io/onjava8/#/book/11-Inner-Classes?id=%e9%97%ad%e5%8c%85%e4%b8%8e%e5%9b%9e%e8%b0%83) 闭包（**closure**）是一个可调用的对象，它记录了一些信息，这些信息来自于创建它的作用域。通过这个定义，可以看出内部类是面向对象的闭包，因为它不仅包含外部类对象（创建内部类的作用域）的信息，还自动拥有一个指向此外部类对象的引用，在此作用域内，内部类有权操作所有的成员，包括**private**成员。 在 Java 8 之前，内部类是实现闭包的唯一方式。在 Java 8 中，我们可以使用 lambda 表达式来实现闭包行为，并且语法更加优雅和简洁，你将会在[函数式编程](https://lingcoder.gitee.io/onjava8/#/)这一章节中学习相关细节。尽管相对于内部类，你可能更喜欢使用 lambda 表达式实现闭包，但是你会看到并需要理解那些在 Java 8 之前通过内部类方式实现闭包的代码，因此仍然有必要来理解这种方式。 Java 最引人争议的问题之一就是，人们认为 Java 应该包含某种类似指针的机制，以允许回调（callback）。通过回调，对象能够携带一些信息，这些信息允许它在稍后的某个时刻调用初始的对象。稍后将会看到这是一个非常有用的概念。如果回调是通过指针实现的，那么就只能寄希望于程序员不会误用该指针。然而，读者应该已经了解到，Java 更小心仔细，所以没有在语言中包括指针。 通过内部类提供闭包的功能是优良的解决方案，它比指针更灵活、更安全。见下例： ~~~ // innerclasses/Callbacks.java // Using inner classes for callbacks // {java innerclasses.Callbacks} package innerclasses; interface Incrementable { void increment(); } // Very simple to just implement the interface: class Callee1 implements Incrementable { private int i = 0; @Override public void increment() { i++; System.out.println(i); } } class MyIncrement { 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; @Override public void increment() { super.increment(); i++; System.out.println(i); } private class Closure implements Incrementable { @Override public void increment() { // Specify outer-class method, otherwise // you'll get an infinite recursion: Callee2.this.increment(); } } Incrementable getCallbackReference() { return new Closure(); } } class Caller { private Incrementable callbackReference; Caller(Incrementable cbh) { 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**的。要想建立与外部世界的任何连接，接口**Incrementable**都是必需的。在这里可以看到，**interface**是如何允许接口与接口的实现完全独立的。 内部类**Closure**实现了**Incrementable**，以提供一个返回**Callee2**的“钩子”（hook）-而且是一个安全的钩子。无论谁获得此**Incrementable**的引用，都只能调用`increment()`，除此之外没有其他功能（不像指针那样，允许你做很多事情）。 **Caller**的构造器需要一个**Incrementable**的引用作为参数（虽然可以在任意时刻捕获回调引用），然后在以后的某个时刻，**Caller**对象可以使用此引用回调**Callee**类。 回调的价值在于它的灵活性-可以在运行时动态地决定需要调用什么方法。例如，在图形界面实现 GUI 功能的时候，到处都用到回调。