Scala 闭包如何转换为 Java 对象？

我目前正在研究不同语言的闭包实现。然而，当谈到 Scala 时，我找不到任何有关如何将闭包映射到 Java 对象的文档。

Scala 函数映射到 FunctionN 对象是有据可查的。我假设对闭包的自由变量的引用必须存储在该函数对象中的某个位置（例如，就像在 C++0x 中所做的那样）。

我还尝试使用 scalac 编译以下内容，然后使用 JD 反编译类文件：

object ClosureExample extends Application { 
  def addN(n: Int) = (a: Int) => a + n
  var add5 = addN(5)
  println(add5(20))
}

在反编译的源代码中，我看到 Function1 的匿名子类型，它应该是我的闭包。但是 apply() 方法是空的，并且匿名类没有字段（可能会存储闭包变量）。我想反编译器没有设法从类文件中获取有趣的部分......

现在回答问题：

• 你知道转变具体是如何进行的吗？
• 你知道它在哪里记录吗？
• 你还有什么办法可以解开这个谜团吗？

让我们拆开一组示例，看看它们有何不同。 （如果使用 RC1，请使用-no-specialization让事情更容易理解。）

class Close {
  var n = 5
  def method(i: Int) = i+n
  def function = (i: Int) => i+5
  def closure = (i: Int) => i+n
  def mixed(m: Int) = (i: Int) => i+m
}

首先我们来看看是什么method does:

public int method(int);
  Code:
   0:   iload_1
   1:   aload_0
   2:   invokevirtual   #17; //Method n:()I
   5:   iadd
   6:   ireturn

非常简单。这是一种方法。加载参数，调用 gettern，添加，返回。看起来就像Java。

怎么样function？它实际上并没有关闭任何数据，但它is一个匿名函数（称为Close$$anonfun$function$1）。如果我们忽略任何特殊化，构造函数和 apply 是最有趣的：

public scala.Function1 function();
  Code:
   0:   new #34; //class Close$$anonfun$function$1
   3:   dup
   4:   aload_0
   5:   invokespecial   #35; //Method Close$$anonfun$function$1."<init>":(LClose;)V
   8:   areturn

public Close$$anonfun$function$1(Close);
  Code:
   0:   aload_0
   1:   invokespecial   #43; //Method scala/runtime/AbstractFunction1."<init>":()V
   4:   return

public final java.lang.Object apply(java.lang.Object);
  Code:
   0:   aload_0
   1:   aload_1
   2:   invokestatic    #26; //Method scala/runtime/BoxesRunTime.unboxToInt:(Ljava/lang/Object;)I
   5:   invokevirtual   #28; //Method apply:(I)I
   8:   invokestatic    #32; //Method scala/runtime/BoxesRunTime.boxToInteger:(I)Ljava/lang/Integer;
   11:  areturn

public final int apply(int);
  Code:
   0:   iload_1
   1:   iconst_5
   2:   iadd
   3:   ireturn

因此，您加载“this”指针并创建一个新对象，该对象将封闭类作为其参数。这确实是任何内部类的标准。该函数不需要对外部类执行任何操作，因此它只调用超级的构造函数。然后，当调用 apply 时，您执行装箱/拆箱技巧，然后调用实际的数学运算 - 也就是说，只需添加 5。

但是如果我们在 Close 中使用变量的闭包呢？设置完全相同，但现在是构造函数Close$$anonfun$closure$1看起来像这样：

public Close$$anonfun$closure$1(Close);
  Code:
   0:   aload_1
   1:   ifnonnull   12
   4:   new #48; //class java/lang/NullPointerException
   7:   dup
   8:   invokespecial   #50; //Method java/lang/NullPointerException."<init>":()V
   11:  athrow
   12:  aload_0
   13:  aload_1
   14:  putfield    #18; //Field $outer:LClose;
   17:  aload_0
   18:  invokespecial   #53; //Method scala/runtime/AbstractFunction1."<init>":()V
   21:  return

也就是说，它检查以确保输入非空（即外部类非空）并将其保存在字段中。现在，在装箱/拆箱包装器之后应用它：

public final int apply(int);
  Code:
   0:   iload_1
   1:   aload_0
   2:   getfield    #18; //Field $outer:LClose;
   5:   invokevirtual   #24; //Method Close.n:()I
   8:   iadd
   9:   ireturn

您会看到它使用该字段来引用父类，并调用 gettern。添加，返回，完成。因此，闭包非常简单：匿名函数构造函数只是将封闭类保存在私有字段中。

现在，如果我们关闭怎么办？not一个内部变量，但是一个方法参数？就是这样Close$$anonfun$mixed$1做。首先，看看是什么mixed方法的作用是：

public scala.Function1 mixed(int);
  Code:
   0:   new #39; //class Close$$anonfun$mixed$1
   3:   dup
   4:   aload_0
   5:   iload_1
   6:   invokespecial   #42; //Method Close$$anonfun$mixed$1."<init>":(LClose;I)V
   9:   areturn

它加载参数m在调用构造函数之前！因此，构造函数如下所示也就不足为奇了：

public Close$$anonfun$mixed$1(Close, int);
  Code:
   0:   aload_0
   1:   iload_2
   2:   putfield    #18; //Field m$1:I
   5:   aload_0
   6:   invokespecial   #43; //Method scala/runtime/AbstractFunction1."<init>":()V
   9:   return

该参数保存在私有字段中。不保留对外部类的引用，因为我们不需要它。你也不应该对 apply 感到惊讶：

public final int apply(int);
  Code:
   0:   iload_1
   1:   aload_0
   2:   getfield    #18; //Field m$1:I
   5:   iadd
   6:   ireturn

是的，我们只需加载存储的字段并进行数学计算。

我不确定你做了什么才没有在你的例子中看到这一点——对象有点棘手，因为它们同时具有MyObject and MyObject$类和方法以一种可能不直观的方式在两者之间分开。但 apply 肯定会应用事物，并且总体而言，整个系统的工作方式几乎与您期望的方式相同（在您坐下来认真思考了很长一段时间之后）。