初探Lambda表達式/Java多核編程【3】Lambda語法與作用域

參數可以聲明為final，也可以添加注解（@Nullable, etc.）。
表達式體部分可以為方法的調用，如str.length()等等，也可以是表達式，如加減乘除等等，即“語句Lambda”與“表達式Lambda”這兩種形式。
另外關於返回值，有則用return sth_to_return;，沒有則用return;或直接不寫返回語句。
最後，需要注意的是Lambda表達式不需要也不允許使用throws關鍵字來聲明可能產生並需要向上拋出的異常。

前幾篇文章中常常將Lambda與匿名內部類做粗淺的類比與對比，現在我們將就這一點做具體深入的分析。

語法

首先在語法層面，Lambda表達式有時候被稱為匿名內部類的“語法糖”，這表明了二者之間存在語法繁簡的明顯區別。

無標識性問題

其次便是標識性問題，我們知道Java中為了區分對象，每一個對象（即使是匿名內部類的實例）都具有唯一標識，而依賴於對象而存在的行為（即我們所說的方法）也會與此標識相關聯。
例如：

String bar = "bar";
String foo = "foo";
System.out.println(bar.hashCode()); // => 97299
System.out.println(foo.hashCode()); // => 101574

但是對於Lambda表達式而言，情況便不是如此的明朗，根據具體情況的不同，Lambda自身可能擁有標識也可能沒有。
況且，Lambda為的就是表示一種行為，趨向於純函數，因此一般情況下是不需要使用標識加以區分的。

作用域規則

再者就是兩者的作用域大小的區別。
對於匿名內部類而言，顯而易見，在類內可以沿用父類型（即函數接口）中的名字。
而對於Lambda，則不能。
我們用Runnable接口來舉一個例子：

public interface LetsRun extends Runnable {
    String aString = "Big brother is watching.";
}

new Thread(
    new LetsRun() {
        @Override
        public void run() {
            System.out.println(aString);
        }
}).run();

顯然，匿名內部類能夠直接沿用我們在LetsRun這個函數式接口中聲明的aString。
寫完這段代碼的同時，IDE給了我一個可以將匿名內部類折疊為Lambda的提示，現在就讓它幫我們自動折疊一下：

new Thread((LetsRun) () -> System.out.println(LetsRun.aString)).run();

注意此時需要打印的內容也同時自動變成了LetsRun.aString，印證了上述特征，即Lambda不能直接訪問父類型中的名字。

關於對外部變量的訪問（後面書中將此稱為“變量捕獲”），不論是匿名內部類還是Lambda，對於域外部變量的權限都是有限的。
在匿名內部類中，可以讀取外部量，但是不允許有修改變量的傾向。
也就是說，沒有嚴格的限制規定被訪問的外部量必須被聲明為final：

// This is OK
String anotherString = "WAR IS PEACE / FREEDOM IS SLAVERY / IGNORANCE IS STRENGTH";
// Also OK
final String finalString = "Nineteen Eighty-Four";

new Thread(new LetsRun() {
    @Override
    public void run() {
        System.out.println(aString + "\n" + anotherString + "\n" + finalString);
    }
}).run();

倘若一旦在方法內修改了anotherString的值，編譯就無法通過。
同樣，折疊為Lambda後，依然是合法的：

new Thread((LetsRun) ()
        -> System.out.println(LetsRun.aString + "\n" + anotherString + "\n" + finalString)).run();

關於變量捕獲的問題是下一小節的重點內容，在此暫時不做深究。

Lambda表達式在定義時，參數部分與表達式體內的命名可以暫時屏蔽掉字段的名稱：

public class Foo {
    String x, y;
    BinaryOperator binaryOperator = (x, y) -> x.hashCode() + y.hashCode();
    // ...
}

另外，Lambda相當於語句塊，因此表達式體內持有和外部相同的語境，即this與super擁有相同含義：

public class MySuperClass {
    public static final String aString = "Father";
}

public class MyClass extends MySuperClass {
    public static final String aString = "Son";
    public void aMethod() {
        new Thread((LetsRun) () -> {
            System.out.println("--- Lambda ---");
            System.out.println(super.aString);
            System.out.println(this.aString);
        }).run();
        System.out.println("--- Outside ---");
        System.out.println(super.aString);
        System.out.println(this.aString);
    }
}

運行結果：

--- Lambda ---
Father
Son
--- Outside ---
Father
Son

Lambda無法引用自身，因此可以用一種尴尬的方式遞歸調用自己：

intUnaryOperator = i -> i == 0 ? 1 : i * intUnaryOperator.applyAsInt(i - 1);

小結

Lambda不從父類型中繼承任何名字，包括：

• 接口的靜態final字段
  
• 接口的靜態嵌套類
  
• 默認方法（將在後續介紹）

將全部被排除在作用域之外。

Lambda參數與表達式體中的局部聲明可以屏蔽字段名。
Lambda中的this和super的含義完全同外部一致。
而若在匿名內部類訪問外部對象的當前實例須用OuterClass.this，非常笨拙：

new Thread((LetsRun) () ->
        System.out.println(Foo.this.getClass().toString())
).run();

遞歸Lambda時須注意Lambda變量無法被初始化，只能直接調用相應函數式接口中的方法。

本章代碼：
Foo.java

import java.util.function.BinaryOperator;

public class Foo {
    String x, y;
    BinaryOperator binaryOperator = (x, y) -> x.hashCode() + y.hashCode();

    public static void main(String[] args) {
        String bar = "bar";
        String foo = "foo";
        System.out.println(bar.hashCode());
        System.out.println(foo.hashCode());
        new Thread((LetsRun) () -> System.out.println(LetsRun.aString)).run();
        String anotherString = "WAR IS PEACE / FREEDOM IS SLAVERY / IGNORANCE IS STRENGTH";
        final String finalString = "Nineteen Eighty-Four";
        new Thread((LetsRun) () -> System.out.println(LetsRun.aString + "\n" + anotherString + "\n" + finalString)).run();

        new MyClass().aMethod();

        new Foo().accessOuterClassInAnnoymousInnerClass();
    }

    public void accessOuterClassInAnnoymousInnerClass() {
        new Thread((LetsRun) () ->
                System.out.println(Foo.this.getClass().toString())
        ).run();
    }
}

LetsRun.java

public interface LetsRun extends Runnable {
    String aString = "Big brother is watching.";
}

MyClass.java

import java.util.function.IntUnaryOperator;

public class MyClass extends MySuperClass {
    public static final String aString = "Son";
    IntUnaryOperator intUnaryOperator = null;

    public void aMethod() {
        new Thread((LetsRun) () -> {
            System.out.println("--- Lambda ---");
            System.out.println(super.aString);
            System.out.println(this.aString);
        }).run();
        System.out.println("--- Outside ---");
        System.out.println(super.aString);
        System.out.println(this.aString);

    }

    public void factorial() {
        intUnaryOperator = i -> i == 0 ? 1 : i * intUnaryOperator.applyAsInt(i - 1);
    }
}

MySuperClass.java

public class MySuperClass {
    public static final String aString = "Father";
}

以及運行結果：

97299
101574
Big brother is watching.
Big brother is watching.
WAR IS PEACE / FREEDOM IS SLAVERY / IGNORANCE IS STRENGTH
Nineteen Eighty-Four
--- Lambda ---
Father
Son
--- Outside ---
Father
Son
class Foo