java中閉包簡單代碼示例（java中閉包簡單代碼示例是什麼）

本文目錄一覽：

• 1、閉包是什麼，有什麼特性，對頁面有什麼影響
• 2、java中的閉包什麼意思，有什麼作用，麻煩高手給解釋下,感謝！
• 3、簡單的閉包問題？

閉包是什麼，有什麼特性，對頁面有什麼影響

閉包是可以包含自由（未綁定到特定對象）變數的代碼塊；這些變數不是在這個代碼塊內或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義（局部變數）。「閉包」 一詞來源於以下兩者的結合：要執行的代碼塊（由於自由變數被包含在代碼塊中，這些自由變數以及它們引用的對象沒有被釋放）和為自由變數提供綁定的計算環境（作用域）。在 Scala、Scheme、Common Lisp、Smalltalk、Groovy、JavaScript、Ruby、 Python、Go、Lua、objective c、swift 以及Java（Java8及以上）等語言中都能找到對閉包不同程度的支持。

閉包 (closure）是個精確但又很難解釋的電腦名詞。在 Perl 裡面，閉包是以 匿名函數的形式來實現，具有持續參照位於該函數範圍之外的文字式變數值的能力。這些外部的文字變數會神奇地保留它們在閉包函數最初定義時的值 （深連結）。

如果一個程式語言容許函數遞迴另一個函數的話 （像 Perl 就是），閉包便具有意義。要注意的是，有些語言雖提供匿名函數的功能，但卻無法正確處理閉包； Python 這個語言便是一例。如果要想多了解閉包的話，建議你去找本功能性程式 設計的教科書來看。Scheme這個語言不僅支持閉包，更鼓勵多加使用。

以下是個典型的產生函數的函數：

sub add_function_generator {

return sub { shift + shift };

}

$add_sub = add_function_generator();

$sum = $add_sub(4,5)； # $sum是 9了

閉包用起來就像是個函數樣板，其中保留了一些可以在稍後再填入的空格。add_function_generator() 所遞迴的匿名函數在技術上來講並不能算是一個閉包， 因為它沒有用到任何位在這個函數範圍之外的文字變數。

把上面這個例子和下面這個make_adder()函數對照一下，下面這個函數所遞迴的匿名函數中使用了一個外部的文字變數。這種指明外部函數的作法需要由 Perl遞迴一個適當的閉包，因此那個文字變數在匿名函數產生之時的值便永久地被鎖進閉包里。

sub make_adder {

my $addpiece = shift;

return sub { shift + $addpiece };

}

$f1 = make_adder(20)；

$f2 = make_adder(555)；

這樣一來$f1($n) 永遠會是 20加上你傳進去的值$n ，而$f2($n) 將 永遠會是 555加上你傳進去的值$n。$addpiece的值會在閉包中保留下來。

閉包在比較實際的場合中也常用得到，譬如當你想把一些程式碼傳入一個函數時：

my $line;

timeout（30,sub { $line = STDIN });

如果要執行的程式碼當初是以字串的形式傳入的話，即’$line = STDIN’ ，那麼timeout() 這個假想的函數在回到該函數被呼叫時所在的範圍後便無法再擷取$line這個文字變數的值了。

語法結構編輯

Groovy的閉包

閉包（Closure）是Java所不具備的語法結構。閉包就是一個代碼塊，用「{ }」包起來。此時，程序代碼也就成了數據，可以被一個變數所引用（與C語言的函數指針比較類似）。閉包的最典型的應用是實現回調函數（callback）。Groovy的API大量使用閉包，以實現對外開放。閉包的創建過程很簡單，例如：

{ 參數 –

代碼…

}

參考下面的例子代碼，定義了c1和c2兩個閉包，並對它們進行調用：

def c1 = { println it }

def c2 = { text – println text }

c1.call(“content1”) //用call方法調用閉包

c2(“content2”) //直接調用閉包

「-；」之前的部分為閉包的參數，如果有多個參數，之間可用逗號分割；「-；」之後的部分為閉包內的程序代碼。如果省略了「-；」和它之前的部分，此時閉包中代碼，可以用名為「it」的變數訪問參數。

閉包的返回值和函數的返回值定義方式是一樣的：如果有return語句，則返回值是return語句後面的內容；如果沒有return語句，則閉包內的最後一行代碼就是它的返回值。[1]

環境表達編輯

在Javascript中閉包（Closure)

什麼是閉包

「官方」的解釋是：所謂「閉包」，指的是一個擁有許多變數和綁定了這些變數的環境的表達式（通常是一個函數），因而這些變數也是該表達式的一部分。

相信很少有人能直接看懂這句話，因為他描述的太學術。我想用如何在Javascript中創建一個閉包來告訴你什麼是閉包，因為跳過閉包的創建過程直接理解閉包的定義是非常困難的。看下面這段

代碼

1

2

3

4

5

6

7

8

9

function a(){

var i=0;

function b(){

alert(++i);

}

return b;

}

var c=a();

c();

特點

這段代碼有兩個特點：

1、函數b嵌套在函數a內部；

2、函數a返回函數b。

這樣在執行完var c=a( )後，變數c實際上是指向了函數b，再執行c( )後就會彈出一個窗口顯示i的值（第一次為1）。這段代碼其實就創建了一個閉包，為什麼？因為函數a外的變數c引用了函數a內的函數b，就是說：

當函數a的內部函數b被函數a外的一個變數引用的時候，就創建了一個閉包。

作用

簡而言之，閉包的作用就是在a執行完並返回後，閉包使得Javascript的垃圾回收機制GC不會收回a所佔用的資源，因為a的內部函數b的執行需要依賴a中的變數。這是對閉包作用的非常直白的描述，不專業也不嚴謹，但大概意思就是這樣，理解閉包需要循序漸進的過程。

在上面的例子中，由於閉包的存在使得函數a返回後，a中的i始終存在，這樣每次執行c（），i都是自加1後alert出i的值。

那 么我們來想像另一種情況，如果a返回的不是函數b，情況就完全不同了。因為a執行完後，b沒有被返回給a的外界，只是被a所引用，而此時a也只會被b引 用，因此函數a和b互相引用但又不被外界打擾（被外界引用），函數a和b就會被GC回收。（關於Javascript的垃圾回收機制將在後面詳細介紹）

另一個例子

模擬私有變數

function Counter(start){

var count = start;

return{

increment:function(){

count++;

},

get:function(){

return count;

}

}

}

var foo =Counter(4);

foo.increment();

foo.get();// 5

結果

這裡，Counter 函數返回兩個閉包，函數 increment 和函數 get。 這兩個函數都維持著 對外部作用域 Counter 的引用，因此總可以訪問此作用域內定義的變數 count.

文法

objective c的閉包（block）

objective c 中的的閉包，是通過block實現的。Apple在C，Objective-C和C++中擴充了Block這種文法的，並且在GCC4.2中進行了支持。你可以把它理解為函數指針，匿名函數，閉包，lambda表達式，這裡暫且用塊對象來表述，因為它們之間還是有些許不同的。

聲明一個塊

如果以內聯方式使用塊對象，則無需聲明。塊對象聲明語法與函數指針聲明語法相似，但是塊對象應使用脫字元(^)而非星號指針 (*)。下面的代碼聲明一個aBlock變數，它標識一個需傳入三個參數並具有float返回值的塊。

float (^aBlock)(const int*, int, float);

l 創建一個塊

塊使用脫字元(^)作為起始標誌，使用分號作為結束標誌。下面的例子聲明一個簡單塊，並且將其賦給之前聲明的block變數（oneFrom）。

int (^oneFrom)(int);

oneFrom = ^(int anInt) {

return anInt – 1;

};

微觀世界

如 果要更加深入的了解閉包以及函數a和嵌套函數b的關係，我們需要引入另外幾個概念：函數的執行環境（execution context）、活動對象（call object）、作用域（scope）、作用域鏈（scope chain）。以函數a從定義到執行的過程為例闡述這幾個概念。

1、當定義函數a的時候，js解釋器會將函數a的作用域鏈（scope chain）設置為定義a時a所在的「環境」，如果a是一個全局函數，則scope chain中只有window對象。

2、當函數a執行的時候，a會進入相應的執行環境（execution context）。

3、在創建執行環境的過程中，首先會為a添加一個scope屬性，即a的作用域，其值就為第1步中的scope chain。即a.scope=a的作用域鏈。

4、然後執行環境會創建一個活動對象（call object）。活動對象也是一個擁有屬性的對象，但它不具有原型而且不能通過JavaScript代碼直接訪問。創建完活動對象後，把活動對象添加到a的作用域鏈的最頂端。此時a的作用域鏈包含了兩個對象：a的活動對象和window對象。

5、下一步是在活動對象上添加一個arguments屬性，它保存著調用函數a時所傳遞的參數。

6、最後把所有函數a的形參和內部的函數b的引用也添加到a的活動對象上。在這一步中，完成了函數b的的定義，因此如同第3步，函數b的作用域鏈被設置為b所被定義的環境，即a的作用域。

到此，整個函數a從定義到執行的步驟就完成了。此時a返回函數b的引用給c，又函數b的作用域鏈包含了對函數a的活動對象的引用，也就是說b可以訪問到a中定義的所有變數和函數。函數b被c引用，函數b又依賴函數a，因此函數a在返回後不會被GC回收。

當函數b執行的時候亦會像以上步驟一樣。因此，執行時b的作用域鏈包含了3個對象：b的活動對象、a的活動對象和window對象，如下圖所示：

如圖所示，當在函數b中訪問一個變數的時候，搜索順序是先搜索自身的活動對象，如果存在則返回，如果不存在將繼續搜索函數a的活動對象，依 次查找，直到找到為止。如果整個作用域鏈上都無法找到，則返回undefined。如果函數b存在prototype原型對象，則在查找完自身的活動對象 後先查找自身的原型對象，再繼續查找。這就是Javascript中的變數查找機制。

應用場景

1、保護函數內的變數安全。以最開始的例子為例，函數a中i只有函數b才能訪問，而無法通過其他途徑訪問到，因此保護了i的安全性。

2、在內存中維持一個變數。依然如前例，由於閉包，函數a中i的一直存在於內存中，因此每次執行c（），都會給i自加1。

以上兩點是閉包最基本的應用場景，很多經典案例都源於此。

回收機制

在Javascript中，如果一個對象不再被引用，那麼這個對象就會被GC回收。如果兩個對象互相引用，而不再被第3者所引用，那麼這兩個互相引用的對象也會被回收。因為函數a被b引用，b又被a外的c引用，這就是為什麼函數a執行後不會被回收的原因。

匿名內部

在Python中的閉包（Closure)

學過Java GUI編程的人都知道定義匿名內部類是註冊監聽等處理的簡潔有效手段，閉包的定義方式有點類似於這種匿名內部類，

但是閉包的作用威力遠遠超過匿名內部類，這也是很多流行動態語言選擇閉包的原因，相信你在JavaScript中已經了解它的神奇功效了。

定義

如果在一個內部函數里，對在外部作用域（但不是在全局作用域）的變數進行引用，那麼內部函數就被認為是閉包（closure）。

簡單閉包的例子：

下面是一個使用閉包簡單的例子，模擬一個計數器，通過將整型包裹為一個列表的單一元素來模擬使看起來更易變：

函數counter（）所作的唯一一件事就是接受一個初始化的值來計數，並將該值賦給列表count成員，然後定義一個內部函數incr（）。通過內部函數使用變數count，就創建了一個閉包。最魔法的地方是counter（）函數返回一個incr（），一個可以調用的函數對象。

運行：

c = counter⑸

type(c)

type ‘function’

print c()6

print c()

7

代碼格式較重要

c2 = counter（99）

100

print c()

8

java中的閉包什麼意思，有什麼作用，麻煩高手給解釋下,感謝！

# 是引用了自由變數的函數。這個函數通常被定義在另一個外部函數中，並且引用了外部函數中的變數。# 是一個可調用的對象，它記錄了一些信息，這些信息來自於創建它的作用域。# 是一個匿名的代碼塊，可以接受參數，並返回一個返回值，也可以引用和使用在它周圍的，可見域中定義的變數。# 是一個表達式，它具有自由變數及邦定這些變數的上下文環境。# 閉包允許你將一些行為封裝，將它像一個對象一樣傳來遞去，而且它依然能夠訪問到原來第一次聲明時的上下文。是指擁有多個變數和綁定了這些變數的環境的表達式（通常是一個函數），因而這些變數也是該表達式的一部分。# 閉包是可以包含自由（未綁定）變數的代碼塊；這些變數不是在這個代碼塊或者任何全局上下文中定義的，而是在定義代碼塊的環境中定義。

簡單的閉包問題？

概念

閉包，在《javascripts高級程序設計》裡面是這樣介紹的:閉包是指有權訪問另一個作用域中的變數的函數。額。。這句話我以前看過很多遍，但依然不是很懂，只知道它是跟作用域有關。現在我知道了，如果這句話換成：但凡是內部的函數被保存到了外部，必定生成閉包。這樣就容易理解多了不是。

我們以下面的這個代碼塊為例：

例子解釋

function a() {const num = 100;function b () {num++;console.log(num);}return b;}const demo = a();demo();demo();

我們先執行上述代碼，看看結果是什麼：

為什麼是這樣呢？

a()執行的結果是返回b，所以demo指的是b,則demo()指的是b();也就是說原先在a裡面的b,在b的外部執行； 

我們已經知道了作用域和作用域鏈的概念,上面代碼的作用域是這樣的:

a執行完，返回了b,此時的b只是聲明，但還沒調用，所以沒有形成自己的AO,但作用域鏈和 a doing 時是一樣的，所以雖然 a() 的作用域被銷毀了，但是相同的一份卻被b保存到了外面。這也就是內部函數被保存到了外面形成閉包的本質。這樣也不難理解為什麼上述代碼列印出來的值是那樣的了：

執行第一個demo()時，也即是執行 b(),由於b保存了a的作用域鏈，所以也可以訪問到 num ,執行 b() 後，加一；

那為什麼第二次執行 demo(),列印出的值還是有自增了呢？這是因為操作的都是保存在 b 里的 num ,雖然每次調用 demo() 都會形成新的作用域鏈，但是num，卻是每次從上一次的作用域鏈直接 copy到當前作用域鏈中的。

這樣形成的閉包雖然可以使外部可以訪問到內部的函數，但是導致了原有的作用域鏈不釋放，會造成內存泄漏。（內存泄漏的意思就是佔用內存，可用內存資源變少了）。所以如果不是特殊需要，應盡量防止這種情況發生。

並且，作用域鏈的配置機制引出了一個值得注意的副作用：即閉包只取得包含函數中任何變數最後一個值，比如下面這個例子：

function createFunctions() {var result = [];for(let i = 0; i 10; i++) {result[i] = function() {console.log(i);}}return result;}var myArr = createFunctions();for(var j = 0; j 10; j++) {myArr[j]();}

這個函數會返回一個函數數組，表面上看，似乎每個函數都應該有自己的索引值，即會返回：0，1，2…9;但實際上，每個函數都會返回10;這是因為在createFunctions()執行時，for循環跳出的條件是i=10；所以函數返回後，i的值是10 ；而每個result的作用域鏈中都保存這createFunctions()的AO,所以他們引用的都是createFunctions()的i值，所以每個函數內部i的值都是10；

這樣，我們可以創建一個立即執行函數強制讓閉包的行為符合預期：

function createFunctions() {var result = [];for(var i = 0; i 10; i++) {(function(j) {result[i] = function() {document.write(j + ” “);}}(i));}return result;}var myArr = createFunctions();for(var j = 0; j 10; j++) {myArr[j]();}

典型應用

下面看看幾個用到閉包的典型例子：

實現共有變數

如累加器:調用多少次，累加多少次，用閉包更加模塊化

function add() {var count = 0;function demo() {count++;console.log(count);}return demo;}var counter = add();counter();//1counter();//2counter();//3

實現緩存

如eater: eat和push保存的都是eater的AO;,所以eat中food改變後。實際上是eater變了，所以也會影響push;

function eater() {var food = ”;var obj = {eat: function() {console.log(‘eating’ + food);food = ”;},push: function(myFood) {food = myFood;}}return obj;// 相當於返回裡面的eat和push操作food;}var eater1 = eater();eater1.push(‘banana’);eater1.eat();