在某乎看到一个提问，怎样用Lambda写阶乘？
由于Java的 Effectively final 特性，以下代码无法通过编译。
Function factorial = null;
factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);有位答主提供了一个方案：在构造函数中初始化：
public class Factorial {
Function factorial = null;
public Factorial() {
factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);
}
public static void main(String[] args) {
System.out.println(new Factorial().factorial.apply(5));
}
}看起来和错误写法差不多，但居然是可用的！但是答主并不知道原理，解释为可能是构造函数的特殊性。
仅仅是因为构造函数吗？我试了下在构造代码块中，在普通函数中，都可以正确初始化。似乎只要lambda函数是类变量就可以。
public class Factorial {
Function factorial = null;
// 构造代码块中初始化
{
factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);
}
// 普通函数初始化
// public Function set() {
// factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);
// return factorial;
// }
public static void main(String[] args) {
System.out.println(new Factorial().factorial.apply(5));
// System.out.println(new Factorial().set().apply(10));
}
}甚至把lambda定义为static，在static块中初始化，也能通过编译。
但是这是为什么呢？
为什么Java要求 Lambda 函数中使用的外部变量必须是 Effectively final？
可以看这篇回答，虽然讲的是匿名内部类，但是原理相通。
简单来讲就是：Java支持了有限的闭包，在编译时给匿名内部类增加了个构造函数，把外部的局部变量复制了一份到内部类里。
用匿名内部类写这样一份测试代码：
public class Func{
public static void main(String[] args){
Integer a = 10, b = 20;
Runnable runnable = new Runnable() {
@Override
public void run(){
System.out.println(a + b);
}
};
runnable.run();
}
}反编译后的结果：
// Func.class，把两个局部变量写为 final
public static void main(String[] var0) {
final Integer var1 = 10;
final Integer var2 = 20;
Runnable var3 = new Runnable() {
public void run() {
System.out.println(var1 + var2);
}
};
var3.run();
}
// Func$1.class，通过构造函数传入了局部变量
final class Func$1 implements Runnable {
Func$1(Integer var1, Integer var2) {
this.val$a = var1;
this.val$b = var2;
}
public void run() {
System.out.println(this.val$a + this.val$b);
}
}通过偷偷塞构造函数的方式，传入了局部变量的一个拷贝。
如果允许修改该局部变量的引用，外部修改无法对内部生效，内部的修改也无法对外部生效，一定程度上会引起歧义，索性写死为final得了。
其他语言是怎么做的？
但是同为JVM语言的Scala，似乎并没有这种限制。
// Scala源码,Lambda 函数中修改number的值，且生效
def tryAccessingLocalVariable{
var number = 1
println(number)
var lambda = () => {
number = 2
println(number)
}
lambda.apply()
println(number)
}
// 编译后，用 IntRef 包装了 number
public final class TryUsingAnonymousClassInScala$$anonfun$1 extends AbstractFunction0.mcV.sp
implements Serializable{
public static final long serialVersionUID = 0L;
private final IntRef number$2;
public final void apply(){
apply$mcV$sp();
}
public void apply$mcV$sp() {
this.number$2.elem = 2;
Predef..MODULE$.println(BoxesRunTime.boxToInteger(this.number$2.elem));
}
public TryUsingAnonymousClassInScala$$anonfun$1(TryUsingAnonymousClassInScala $outer, IntRef number$2) {
this.number$2 = number$2;
}
}Scala是通过 IntRef 包装以后传入的，修改时通过IntRef.elem = 2;的方式，并未修改IntRef的引用，实际IntRef还是final的。
手动绕过外部变量不允许修改的限制
和Scala类似，在Java里，我们给变量加个包装即可，只不过需要手动添加。据说JDK里有很多代码就是这样干的。
int a[] = {0};
Runnable runnable = () -> a[0]++;
匿名函数/Lambda函数对类变量的处理
匿名函数和Lambda函数在这方面有相似的特性，所以把最开始那个阶乘代码写成匿名函数的方式并反编译(Lambda反编译看不到细节)：
// 源码
public class Factorial{
static Function factorial = null;
static {
factorial = new Function() {
@Override
public Integer apply(Integer i){
return i == 0 ? 1 : i * factorial.apply(i - 1);
}
};
}
public static void main(String[] args){
System.out.println(Factorial.factorial.apply(10));
}
}
// 匿名函数反编译后的类
class Factorial$1 implements Function{
Factorial$1(Factorial var1) {
this.this$0 = var1;
}
public Integer apply(Integer var1){
return var1 == 0 ? 1 : var1 * (Integer)Factorial.factorial.apply(var1 - 1);
}
}编译器在匿名类的构造函数里把外部对象给传了进来，和内部类非常相似。
所以明显的，在这种情况下，看起来似乎绕过了 Effectively final 特性，实际是匿名函数/Lambda函数持有了外部对象的引用！
为什么JDK要用如此别扭的方式，而不是像Scala那样支持完整的闭包？
openJDK给出的回答是，类似Scala这种处理方式，在多线程下会有问题。相比它的好处，它带来的问题似乎更严重。
最初问题的答案
只需要让Lambda函数编译生成的类传入外部对象的引用，即可达到“看起来绕过Effectively final特性”的效果。
Lamabda 阶乘的另一种写法
由于数组也是特殊的对象，所以还可以这样写：
Function[] funcs = new Function [1];
funcs[0] = i -> i == 0 ? 1 : i * funcs[0].apply(i - 1);
System.out.println(funcs[0].apply(5));更简单直观。
