टॉम हॉकिन के अनुसार
क्लोजर कोड का एक ब्लॉक है जिसे संदर्भित किया जा सकता है (और चारों ओर पारित किया गया) जो एन्क्लेविंग स्कोप के चर तक पहुंच के साथ है।
अब मैं पर JavaScript बंद उदाहरण का अनुकरण करने के लिए कोशिश कर रहा हूँ विकिपीडिया , एक "के साथ straigth उपयोगी होने के लिए, जावा के लिए" अनुवाद आशा में:
//ECMAScript
var f, g;
function foo() {
var x = 0;
f = function() { return ++x; };
g = function() { return --x; };
x = 1;
print('inside foo, call to f(): ' + f()); // "2"
}
foo();
print('call to g(): ' + g()); // "1"
print('call to f(): ' + f()); // "2"
अब जावा भाग: फंक्शन 1 "फनकार" है जिसका अर्थ है एरिटी 1 (एक तर्क)। क्लोजर फ़ंक्शन 1 को लागू करने वाला वर्ग है, एक ठोस फ़नकार जो फ़ंक्शन (इंट -> इंट) के रूप में कार्य करता है। जावास्क्रिप्ट उदाहरण से कॉल की नकल करते हुए मुख्य () विधि में मैं सिर्फ एक क्लोजर ऑब्जेक्ट के रूप में फू को इंस्टेंट करता हूं। इंटॉक्स क्लास सिर्फ एक साधारण कंटेनर है, यह 1 इंट के सरणी की तरह व्यवहार करता है:
int [1] = {0}
interface Function1 {
public final IntBag value = new IntBag();
public int apply();
}
class Closure implements Function1 {
private IntBag x = value;
Function1 f;
Function1 g;
@Override
public int apply() {
// print('inside foo, call to f(): ' + f()); // "2"
// inside apply, call to f.apply()
System.out.println("inside foo, call to f.apply(): " + f.apply());
return 0;
}
public Closure() {
f = new Function1() {
@Override
public int apply() {
x.add(1);
return x.get();
}
};
g = new Function1() {
@Override
public int apply() {
x.add(-1);
return x.get();
}
};
// x = 1;
x.set(1);
}
}
public class ClosureTest {
public static void main(String[] args) {
// foo()
Closure foo = new Closure();
foo.apply();
// print('call to g(): ' + g()); // "1"
System.out.println("call to foo.g.apply(): " + foo.g.apply());
// print('call to f(): ' + f()); // "2"
System.out.println("call to foo.f.apply(): " + foo.f.apply());
}
}
यह प्रिंट करता है:
inside foo, call to f.apply(): 2
call to foo.g.apply(): 1
call to foo.f.apply(): 2