Thursday, December 26, 2013

What is closure? It is supposed to be included in Java 7. Can anyone please provide me with some reliable references from where I can learn stuff about closures?
share|improve this question
11 
It got pushed to the next release unfortunately. –  Johan Sjöberg Mar 26 '11 at 16:09
add comment

6 Answers

up vote24down voteaccepted
Here is the Neal Gafter's blog one of the pioneers introducing closures in Java. On his blog there is lots of information to get you started as well as videos. And in here is an excellent Google talk Advanced Topics In Programming Languages - Closures For Java with Neal Gafter as well.
share|improve this answer
 
+1 That google talk is highly recommended. –  Erick Robertson Sep 28 '12 at 15:55
add comment
A closure is a block of code that can be referenced (and passed around) with access to the variables of the enclosing scope.
Since Java 1.1, anonymous inner class have provided this facility in a highly verbose manner. They also have a restriction of only being able to use final (and definitely assigned) local variables. (Note, even non-final local variables are in scope, but cannot be used.)
Java SE 8 is intended to have a more concise version of this for single-method interfaces*, called "lambdas". Lambdas have much the same restrictions as anonymous inner classes, although some details vary randomly.
Lambdas are being developed under Project Lambda and JSR 335.
*Originally the design was more flexible allowing Single Abstract Methods (SAM) types. Unfortunately the new design is less flexible, but does attempt to justify allowing implementation within interfaces.
share|improve this answer
 
Here is a closure implementation for Java 5, 6, and 7 mseifed.blogspot.se/2012/09/… It contains all one could ask for... i think it is pretty awesome –  SecretService Sep 29 '12 at 20:46
add comment
Please see this wiki page for definition of closure.
Also look at this Q&A: Closures in Java 7
share|improve this answer
add comment
Java Closures are going to be a part of J2SE 8 and is set to be released by the end of 2012.
Java 8's closures support include the concept of Lambda Expressions, Method Reference, Constructor Reference and the Default Methods.
For more information and working examples for this please visit: http://amitrp.blogspot.in/2012/08/at-first-sight-with-closures-in-java.html
share|improve this answer
add comment
A closure implementation for Java 5, 6, and 7
It contains all one could ask for...
share|improve this answer
 
It is pretty awesome actually! –  SecretService Apr 19 at 20:49
add comment
According to Tom Hawtin
A closure is a block of code that can be referenced (and passed around) with access to the variables of the enclosing scope.
Now I'm trying to emulate the JavaScript closure example on Wikipedia, with a "straigth" translation to Java, in the hope to be useful:
//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"
Now the java part: Function1 is "Functor" interface with arity 1 (one argument). Closure is the class implementing the Function1, a concrete Functor that acts as function (int -> int). In the main() method I just instantiate foo as a Closure object, replicating the calls from the JavaScript example. The IntBox class is just a simple container, it behave like an array of 1 int:
int a[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());

   }
  }
It prints:
inside foo, call to f.apply(): 2
call to foo.g.apply(): 1
call to foo.f.apply(): 2 
share|improve this answer
add comment

No comments: