java 閉包的用途是什么

閉包是一種編程概念，主要用在函數(shù)式編程中，其主要用途包括：

• 數(shù)據(jù)封裝和私有變量：閉包可以使我們在函數(shù)內部創(chuàng)建私有變量，只能通過特定的公開方法進行訪問和修改。這是模塊模式的基礎。
• 實現(xiàn)回調函數(shù)和高階函數(shù)：閉包常常被用來作為回調函數(shù)，因為它們可以記住自己的詞法環(huán)境，包括 this 和外部變量。
• 實現(xiàn)裝飾器/函數(shù)修飾器：閉包可以用于修改或增強函數(shù)的行為。例如，可以創(chuàng)建一個閉包來“記住”前一個函數(shù)的調用并據(jù)此改變下一個函數(shù)調用。
• 實現(xiàn)柯里化（Currying）：閉包可以用于實現(xiàn)柯里化，即把一個接受多個參數(shù)的函數(shù)變換成接受一個單一參數(shù)（最初函數(shù)的第一個參數(shù)）的函數(shù)，并且返回接受余下的參數(shù)且返回結果的新函數(shù)的技術。

然而，雖然閉包有很多用途，但也需要謹慎使用。因為閉包可以保留其詞法環(huán)境，導致內存消耗增加，如果不當使用，可能會引發(fā)內存泄露的問題。因此，在使用閉包時，需要注意及時清理不再需要的閉包，避免造成內存浪費。

Lambda表達式如何實現(xiàn)函數(shù)閉包

在Java 8及之后的版本中，Lambda表達式是一種簡潔、函數(shù)式編程的方法，可以創(chuàng)建只有一個抽象方法的接口（稱為函數(shù)式接口）的實例。然而，Java的Lambda表達式并不直接支持傳統(tǒng)意義上的“函數(shù)閉包”，這是因為Java是一種靜態(tài)類型語言，并且在設計之初并沒有考慮閉包的概念。

不過，Java 8引入了一些新特性，如Lambda表達式和函數(shù)式接口，這些特性在某些程度上模擬了閉包的行為。特別是，Java 8中的Function，Consumer，Predicate等接口，允許你將代碼作為參數(shù)傳遞，并允許在后續(xù)的執(zhí)行過程中引用這些代碼。

以下是一個使用Java Lambda表達式模擬函數(shù)閉包的例子：

import java.util.function.Function;

public class LambdaClosureExample {
    public static void main(String[] args) {
        // 定義一個Lambda表達式，它接受一個整數(shù)并返回其平方
        Function<Integer, Integer> square = x -> x * x;

        // 使用Lambda表達式計算5的平方
        int result = square.apply(5);
        System.out.println("5的平方是: " + result);

        // 使用Lambda表達式計算10的平方
        result = square.apply(10);
        System.out.println("10的平方是: " + result);
    }
}

在這個例子中，square變量是一個Function接口的實例，它接受一個整數(shù)并返回其平方。你可以將這個Function對象傳遞給其他方法，并在后續(xù)的執(zhí)行過程中使用它。這在一定程度上模擬了函數(shù)閉包的行為，因為它允許你在后續(xù)的執(zhí)行過程中引用和重用一段代碼。

然而，需要注意的是，盡管Java的Lambda表達式和函數(shù)式接口在某些情況下可以模擬閉包的行為，但它們并不完全等同于傳統(tǒng)意義上的閉包。在Java中，你仍然不能直接引用外部作用域的變量（除非這些變量是final的），因此Java的Lambda表達式并不支持真正的閉包語義。

附：關于Java閉包為什么規(guī)定局部變量是final

Java規(guī)定：閉包函數(shù)使用的局部變量必須是final或者effectively final ( 等效 final ) 的。但是，從直觀上看，即使在方法體內改了局部變量，也不像能導致什么謬誤的樣子。所以，這個final的規(guī)矩讓人心生疑惑。

• 先po代碼（來自《On Java 8》）：

// lambda使用的局部變量必須是final或等效final...

// 基本類型
class Closure6 {
    IntSupplier makeFun(int x) {  // IntSupplier接口中只有一個方法getAsInt()，無參，返回值類型int.
        int i = 0;
        i++;
        x++;
        // return () -> x + i;  // 編譯器報錯: Variables in lambda expressions must be final or effectively final.
        						// 即：lambda表達式中的變量必須是final 或者 effectively final.
        // 不報錯的做法：
        final int iFinal = i;  // final關鍵字在這里很多余.
        final int xFinal = x;  // 因為這兩個變量賦值后沒有做任何更改，是等效final的.
        return () -> xFinal + iFinal;
    }
}

// 對象引用
class Closure9 {
    Supplier<List<Integer>> makeFun() {  // Supplier接口中只有一個方法get()，無參，返回<>中類型，此處即 List<Integer>.
        List<Integer> ai = new ArrayList<>();
//        ai = new ArrayList<>(); // Reassignment
        return () -> ai;  // 若前一行不注釋, 則這里報錯.
    }
}

class Closure1 {
    int i;
    IntSupplier makeFun(int x) {
        return () -> x + i++;  // 使用類成員變量時，可以更改而不報錯。
    }
}

這兩個報錯展示了文章開頭的規(guī)則。那么這是為啥嘞？

• 我們已經(jīng)知道，一個局部變量在它的作用域之外是不存在的，那么把它放在lambda表達式里并返回至作用域外，看起來好像需要java的“特許”。

• 根據(jù)這個猜想，我原以為：java出于某種善意避免程序員犯錯，所以立下了規(guī)矩，即：被lambda“捕捉”的局部變量必須是final或者"等效final"的，來避免變量被重復訪問修改，從而導致confusion（混淆）。

• 但遺憾的是，我高估了java的“善意”了，通過RednaxelaFX大佬的解析習得：實際上java只是copy了一份value到表達式中（capture-by-value），而不是capture-by-reference（比如C#把被捕獲的局部變量“提升”（hoist）到對象里，使變量依托于對象存在），所以lambda使用的變量跟最初定義的局部變量（包括基本類型標識符和對象引用）徹底脫鉤了。lambda表達式訪問的只是一個副本。

• 而為了掩飾這種“簡單粗暴”導致的“變量不能再次訪問”，java干脆告訴你：“變量定義之后就別改了哈”，好像不能再次訪問的原因僅僅是這個規(guī)定而已。但實際上由于java并沒有實現(xiàn)capture-by-reference，因此對于一個離開了作用域就不復存在的局部變量，你即便想改，也改不了。所以，這個規(guī)定好像脫褲子放屁，掩耳盜鈴了。

• 被lambda使用的類成員變量則沒有這樣的束縛，這是因為，（非static）成員變量只依賴于對象存在。而這個對象以一種看不見的“this”方式存在于lambda表達式的參數(shù)列表中，所以垃圾回收器不會去傷害這個對象（這個原則對普通函數(shù)同樣適用）。故，類成員變量不需要被主動capture（捕獲），這也印證了代碼在Closure1處為何不報錯，因為變量 i 始終有參數(shù)中隱含的this對象可以依賴。

總結

到此這篇關于java閉包用途是什么的文章就介紹到這了,更多相關java閉包用途內容請搜索腳本之家以前的文章或繼續(xù)瀏覽下面的相關文章希望大家以后多多支持腳本之家！

最新評論