Java之lambda表示式

gonghr發表於2021-03-27
Java

函數語言程式設計思想概述

在數學中，函式就是有輸入量、輸出量的一套計算方案，也就是“拿資料做操作” 物件導向思想強調“必須通過物件的形式來做事情”

函式式思想則儘量忽略物件導向的複雜語法：“強調做什麼，而不是以什麼形式去做” 而我們要學習的Lambda表示式就是函式式思想的體現

Lambda表示式的標準格式

格式：
(形式引數) -> {程式碼塊}
形式引數：如果有多個引數，引數之間用逗號隔開；如果沒有引數，留空即可
->：由英文中畫線和大於符號組成，固定寫法。代表指向動作
程式碼塊：是我們具體要做的事情，也就是以前我們寫的方法體內容
 
組成Lambda表示式的三要素：
形式引數，箭頭，程式碼塊

無參無返回值抽象方法

Lambda表示式的使用前提
有一個介面
介面中有且僅有一個抽象方法
 
操作步驟
定義一個介面(Eatable)，裡面定義一個抽象方法：void eat();
定義一個測試類(EatableDemo)，在測試類中提供兩個方法
一個方法是：useEatable(Eatable e)
一個方法是主方法，在主方法中呼叫useEatable方法
//介面
interface Eatable {
    void eat();
}

//實現類
class EatableImpl implements Eatable {
    @Override
    public void eat() {
        System.out.println("一天一蘋果，醫生遠離我");
    }
}

//測試類
public class test {
    public static void main(String[] args) {
//在主方法中呼叫useEatable方法
        Eatable e = new EatableImpl();  //父類引用指向子類物件
        useEatable(e);

        //匿名內部類
        useEatable(new Eatable() {
            @Override
                public void eat() {
                System.out.println("一天一蘋果，醫生遠離我");
            }
        });
        //Lambda表示式

        useEatable(()-> {
            System.out.println("一天一蘋果，醫生遠離我");
});
    }

    private static void useEatable(Eatable e) {
        e.eat();
    }
}

有參無返回值抽象方法

操作步驟
定義一個介面(Flyable)，裡面定義一個抽象方法：void flfly(String s);
定義一個測試類(FlyableDemo)，在測試類中提供兩個方法
一個方法是：useFlyable(Flyable f)
一個方法是主方法，在主方法中呼叫useFlyable方法
interface Flyable {
    void fly(String s);
}

public class test {
    public static void main(String[] args) {
//在主方法中呼叫useFlyable方法
//匿名內部類
        useFlyable(new Flyable() {
            @Override
            public void fly(String s) {
                System.out.println(s);
                System.out.println("飛機自駕遊");
            }
        });
        System.out.println("‐‐‐‐‐‐‐‐");

//Lambda

        useFlyable((String s) -> {
            System.out.println(s);
            System.out.println("飛機自駕遊");
        });

    }

    private static void useFlyable(Flyable f) {
        f.fly("風和日麗，晴空萬里");
    }
}

有參有返回值抽象方法

操作步驟
定義一個介面(Addable)，裡面定義一個抽象方法：int add(int x,int y);
定義一個測試類(AddableDemo)，在測試類中提供兩個方法
一個方法是：useAddable(Addable a)
一個方法是主方法，在主方法中呼叫useAddable方法
interface Addable {
    int add(int x, int y);
}

public class test {
    public static void main(String[] args) {
//在主方法中呼叫useAddable方法
        useAddable((int x, int y) -> {
            return x + y;
        });
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

Lambda表示式的省略模式

省略的規則
引數型別可以省略。但是有多個引數的情況下，不能只省略一個
如果引數有且僅有一個，那麼小括號可以省略
如果程式碼塊的語句只有一條，可以省略大括號和分號，和return關鍵字
interface Addable {
    int add(int x, int y);
}

interface Flyable {
    void fly(String s);
}

public class test {
    public static void main(String[] args) {
        // useAddable((int x,int y) ‐> {
        // return x + y;
        // });
        // 引數的型別可以省略
        useAddable((x, y) -> {
            return x + y;
        });
        //useFlyable((String s) ‐> {
        // System.out.println(s);
        // }); //如果引數有且僅有一個，那麼小括號可以省略
        // useFlyable(s ‐> {
        // System.out.println(s);
        // });
        // 如果程式碼塊的語句只有一條，可以省略大括號和分號
        useFlyable(s -> System.out.println(s));
        // 如果程式碼塊的語句只有一條，可以省略大括號和分號，如果有return，return也要省略掉
        useAddable((x, y) -> x + y);
    }

    private static void useFlyable(Flyable f) {
        f.fly("風和日麗，晴空萬里");
    }

    private static void useAddable(Addable a) {
        int sum = a.add(10, 20);
        System.out.println(sum);
    }
}

Lambda表示式的使用前提

使用Lambda必須要有介面
並且要求介面中有且僅有一個抽象方法

Lambda表示式和匿名內部類的區別

所需型別不同
匿名內部類：可以是介面，也可以是抽象類，還可以是具體類
Lambda表示式：只能是介面
 
使用限制不同
如果介面中有且僅有一個抽象方法，可以使用Lambda表示式，也可以使用匿名內部類
如果介面中多於一個抽象方法，只能使用匿名內部類，而不能使用Lambda表示式
 
實現原理不同
匿名內部類：編譯之後，產生一個單獨的.class位元組碼檔案
Lambda表示式：編譯之後，沒有一個單獨的.class位元組碼檔案。對應的位元組碼會在執行的時候動態生成

相關文章