Java8 中 Lambda函数的 Effectively final 特性——从阶乘提及

在某乎看到一个提问，怎样用Lambda写阶乘？

因为Java的 Effectively final 特性，如下代码没法经过编译。

Function<Integer, Integer> factorial = null;
factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);

有位答主提供了一个方案：在构造函数中初始化：

public class Factorial {
    Function<Integer, Integer> 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<Integer, Integer> factorial = null;

    // 构造代码块中初始化
    {
        factorial = i -> i == 1 ? 1 : i * factorial.apply(i - 1);
    }

    // 普通函数初始化
//    public Function<Integer, Integer> 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<Integer, Integer> factorial = null;

    static {
        factorial = new Function<Integer, Integer>() {
            @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<Integer, Integer> {
    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<Integer, Integer>[] funcs = new Function [1];
funcs[0] = i -> i == 0 ? 1 : i * funcs[0].apply(i - 1);
System.out.println(funcs[0].apply(5));