什么是闭包？ java有闭包吗？

Question

我在阅读面向对象的 Javascript 并发现了闭包的概念。我不太明白为什么以及何时使用它。像 Java 这样的其他语言也有闭包吗？我基本上想了解了解闭包的概念如何帮助我改进我的编码。

Answer 1

闭包是带有绑定变量的第一类函数。

大致意味着：

• 您可以将闭包作为参数传递给其他函数
• 闭包存储创建时存在的词法作用域中的一些变量的值

Java 最初没有对闭包的语法支持（这些是在 Java 8 中引入），尽管使用匿名内部类来模拟它们是相当常见的做法。这是一个例子：

import java.util.Arrays;
import java.util.Comparator;

public class StupidComparator { 
    public static void main(String[] args) {
        // this is a value used (bound) by the inner class
        // note that it needs to be "final"
        final int numberToCompareTo=10;

        // this is an inner class that acts like a closure and uses one bound value
        Comparator<Integer> comp=new Comparator<Integer>() {
            public int compare(Integer a, Integer b) {
                int result=0;
                if (a<numberToCompareTo) result=result-1;
                if (b<numberToCompareTo) result=result+1;
                return result;
            }
        };

        Integer[] array=new Integer[] {1,10, 5 , 15, 6 , 20, 21, 3, 7};

        // this is a function call that takes the inner class "closure" as a parameter
        Arrays.sort(array,comp);

        for (int i:array) System.out.println(i);
    }
}

Answer 2

闭包在各种语言中有不同的名称，但要点如下：

要创建闭包，您需要一种函数类型为一等公民的语言，即它可以绑定到变量并像任何旧字符串、int 一样传递或布尔值。

您还需要能够内联声明函数。在 javascript 中，您可以执行以下操作：

foo("bar", "baz" function(x){alert("x")});

将匿名函数作为参数传递给 foo 函数。我们可以用它来创建一个闭包。

闭包“关闭”变量，因此可用于传递作用域变量。考虑这个例子：

function foo(){
    var spam = " and eggs";
    return function(food){alert(food + spam)};
}
var sideOfEggs = foo();

鸡蛋的一侧现在包含一个函数，它将“和鸡蛋”附加到它传递的任何食品上。 spam 变量是 foo 函数作用域的一部分，当函数退出时，它就会丢失，除非闭包“封闭”命名空间，只要闭包保留在内存中，就会保留它。

所以我们很清楚闭包可以访问其父级的私有范围变量，对吧？那么如何使用它们来模拟 javascript 中的私有访问修饰符呢？

var module = (function() {   
    var constant = "I can not be changed";

     return {
         getConstant    :    function() {  //This is the closure
            return constant;               //We're exposing an otherwise hidden variable here
         }
    };
}());                                     //note the function is being defined then called straight away

module.getConstant();                     //returns "I can not be changed"
module.constant = "I change you!";
module.getConstant();                     //still returns "I can not be changed" 

所以这里发生的是我们正在创建并立即调用一个匿名函数。函数中有一个私有变量。它返回一个对象，该对象具有引用该变量的单个方法。一旦函数退出， getConstant 方法就是访问变量的唯一方法。即使这种方法被删除或替换，它也不会放弃它的秘密。我们使用了闭包来实现封装和变量隐藏。有关此内容的更全面说明，请参阅 http://javascript.crockford.com/private.html

Java 还没有闭包。最接近的是匿名内部类。然而，要实例化其中一个内联对象，您必须实例化整个对象（通常来自现有接口）。闭包的美妙之处在于它们封装了简单、富有表现力的语句，这些语句在匿名内部类的噪音中有些丢失。

Answer 3

虽然 Java 没有一等函数，但它实际上有词法闭包。

例如，下面的 Lisp 函数（摘自 Paul Graham 的《On Lisp》一书）返回一个添加数字的函数：

(defun make-adder (n)
  (lambda (x) (+ x n))

这可以在 Java 中完成。但是，由于它没有一等函数，因此我们需要定义一个接口（我们称之为 Adder）和一个带有实现该接口的函数的匿名内部类。

public interface Adder {
    int add(int x);
}

public static Adder makeAdder(final int n) {
    return new Adder() {
        public int add(int x) {
            return x + n;
        }
    };
}

内部 add() 函数是一个词法闭包，因为它使用外部词法范围中的 n 变量。

为此，必须将变量声明为final，这意味着该变量无法更改。然而，改变参考变量中的值是可能的，即使它们是最终的。例如，考虑以下 Lisp 函数（也来自 On Lisp）：

(defun make-adderb (n)
  (lambda (x &optional change)
    (if change
        (setq n x)
        (+ n n))))

这可以通过将外部变量包装在引用类型变量（例如数组或对象）中来在 Java 中实现。

public interface MutableAdder {
    int add(int x, boolean change);
}

public static MutableAdder makeAdderB(int n) {
    final int[] intHolder = new int[] { n };
    return new MutableAdder() {
        public int add(int x, boolean change) {
            if (change) {
                intHolder[0] = x;
                return x;
            }
            else {
                return intHolder[0] + x;
            }
        }
    };
}

我会声称这是真正的词汇闭包，而不是模拟。但我不会说它很漂亮。

Answer 4

闭包是一种范围界定技术。 Java 没有闭包。

在 javascript 中，您可以执行如下操作：

var scope = this;

var f = function() {
    scope.somethingOnScope //scope is 'closed in' 
}

如果您执行类似将 f 传递给函数的操作，则范围是定义它的范围。

Answer 5

闭包是一个非常自然的功能，它允许自由变量被其词法环境捕获。

这是 javascript 中的一个示例：

function x() {

    var y = "apple";

    return (function() {
         return y;
    });
}

函数 x 返回一个函数。请注意，当创建函数时，该函数中使用的变量不会像我们返回表达式时那样进行计算。创建函数时，它会查看哪些变量不是函数的本地变量（自由）。然后，它找到这些自由变量并确保它们不会被垃圾回收，以便在函数实际调用时可以使用它们。

为了支持这个特性，你需要有java不支持的一流函数。

请注意，这是我们在 JavaScript 等语言中拥有私有变量的一种方式。