Home » Core Java » Groovy Closure Example

About Akin Kaldiroglu

Akin Kaldiroglu is a Java consultant and trainer living in İstanbul, Turkey. He has been involved in many enterprise projects with different roles since mid 90s. At the beginning he started coding with C and C++ and then switched to Java when it arrived. He loves developing software and writing code in Java. He is a fan of clean and object-oriented code.

Groovy Closure Example

In this example I’ll explain closures in Groovy.

According to Sabesta’s nice book Concepts of Programming Languages, defining a closure is a simple matter: “a closure is a subprogram and the referencing environment where it was defined.” But explaining it is not that simple. Sabesta explains the closure as a subprogram that can be assigned to a variable or passed to another subprogram so that it can be called anywhere. So far this may not be astonishing. But what is interesting is the fact that assigned or passed subprogram should be able to access all of the variables in its referencing environment. So we can call a closure an anonymous function with a storage.

Groovy as many other programming languages with some functional structures provides closures.

And now the real question comes: why do I need such an awkward structure? Of course to write shorter and more modular programs. Let’s imagine you have several methods that share only a few lines. Most of the time you factor out those shared lines into another method so that your original methods would make a call to this new method. That is modularising the methods. You can think of a closure as the function factored out in this example with one huge difference: Instead of calling the closure in your original methods, you are passing the closure back to those methods as if it were a variable.

That’s why in languages that support closures, they are called “first-class objects”. On the other hand the functions that receive or return (or both) closures are called higher-order function.

Instead of delving into the theoretical details of the concept, let’s focus on how Groovy provides closures as one of its main structures. According to Groovy’s standard documentation a closure in Groovy is an open, anonymous, block of code that can take arguments, return a value and be assigned to a variable. That means as we can pass a variable around the program we can pass closures back and forth in the program.

1. Defining a Closure in Groovy

In Groovy you can define a closure as a block between two curly brackets “{ [closureParameters -> ] statements }“. In this format [closureParameters->] is an optional comma-delimited list of parameters, and statements are 0 or more Groovy statements. The parameters look similar to a method parameter list, and these parameters may be typed or untyped. When a parameter list is specified, the “->” character is required to separate the parameters from the closure body.

Here are some example closure definitions and what they mean:

   
   { "hello" }            // A closure that receives no argument but returns a String object.
   { it -> println it }   // A closure that prints what is passed. "it" is the explicit 
                          // reference to the parameter passed to the closure.
   { println it }         // A closure that prints what is passed. "it" is the implicit 
                          // reference to the parameter passed. 
                          // You can omit the parameter if only one parameter is passed.
   { name -> println name }  // Same closure with different parameter name.
   {double x, double y -> println Math.pow(x, y)}  // A closure that receives two parameters 
                                                   // and prints the value of the first
                                                   // parameter raised to the power of the second one.

As you notice, a closure may have zero or more arguments but does not have any name.

In Groovy a closure must be either assigned to a variable or attached to a method. So closures defined above should be used as explained below.

2. Using Closures in Groovy

A closure is an instance of the groovy.lang.Closure class. So you can treat it as an object and call for example call() method on it. You can also use instanceof operator  check to see if it is instance of the Closure. For example:

   
   def closure1 = { 10 }       // Defining a closure of value "10"
   println(closure1.call())    // Will print out "10"
   assert closure1() == 10     // Assertion holds true
   def b = closure instanceof Closure
   println(b)                  // Prints true
   
   def closure2 = { print 10 }     // Defining a closure to print "10"
   closure2.call()                 // Will print out "10"
   
   def closure3 = { println it }   // Defining a closure to print the passed parameter
   closure3.call(5)         	   // Will print out "5"
   closure3.call() ;        	   // Will print out "null"
   { it -> println it }.call(5)    // Will print out "5"

One of the places where closures are frequently used are collections. For example in Groovy following code snippet prints out all of the elements in the list:

 
   def List numbers = [1, 2, 3, 5, 8, 13, 21]
   for(n in numbers)
      print n

But using closures you can do the same thing in a more elegant way:

 
   def List numbers = [1, 2, 3, 5, 8, 13, 21]
   numbers.each {print it + ', '}

Groovy uses Java’s collections but enhances their API with several methods that receive a Closure object. For example methods each() or find() may receive a Closure object. Here are some examples of using closure with collections:

   
   def List numbers = [1, 2, 3, 5, 8, 13, 21]
   numbers.each {print it + ', '}   // Prints 1, 2, 3, 5, 8, 13, 21,

   def found = numbers.find {it % 2 == 0}
   println(found)                   // Prints 2
		
   List foundNumbers = numbers.findAll {it % 2 == 0}
   println(foundNumbers)            // Prints [2, 8]

You can pass a closure to a method. Following example shows how to do it:

 
   def static callAMethod(){
      def aClosure = { it -> println it }
      aMethod(10, aClosure);
      aMethod(10, { it -> println it })
      aMethod(10) { it -> println it }
      aMethod(23, aClosure);
   }

   def static aMethod(int i, closure){
      println"Here is the output of passed closure:"
      closure(i)
   }

As a last example let’s try to understand how closures help us make our code more modular. Think about following class with three methods:

EvenNumberCalculations.groovy

 
class EvenNumberCalculations {
   static main(args) {
      def obj = new EvenNumberCalculations()
		
      obj.printEvenNumbers(10)
      def result = obj.calculateSumOfEvenNumbers(10);
      println('Total: ' + result)

      result = obj.calculateProductOfEvenNumbers(10);
      println('Product: ' + result)
		
      result = obj.calculateSquareOfEvenNumbers(10);
      println('Squared: ' + result)
   }

   def printEvenNumbers(int n){
      for(int i = 2; i <= n; i += 2) {
         println(i)
      }
   }

   int calculateSumOfEvenNumbers(int n){
      def sum = 0;
      for(int i = 2; i <= n; i += 2) {
         sum += i
      }
      return sum;
   }

   int calculateProductOfEvenNumbers(int n){
      def product = 1;
         for(int i = 2; i <= n; i += 2) {
         product *= i
      }
      return product;
   }

   int[] calculateSquareOfEvenNumbers(int n){
      def squared = []
      for(int i = 2; i <= n; i += 2) {
         squared << i ** 2
      }
      return squared;
   }
}

How can we utilise closures here? We can factor out what is done in for loops of these methods and express them as closures. So we would re-write the same class using closures:

EvenNumberCalculationsWithClosure.groovy

 
class EvenNumberCalculationsWithClosure {

   static main(args) {
      def obj = new EvenNumberCalculationsWithClosure()
      obj.pickEvenNumbers(10, { println it })
		
      def total = 0
      obj.pickEvenNumbers(10) { total += it }
      println('Total: ' + total)
		
      def product = 1
      obj.pickEvenNumbers(10) { product *= it }
      println('Product: ' + product)
		
      def squared = []
      obj.pickEvenNumbers(10) { squared << it ** 2 }
      println('Squared: ' + squared)
   }

   def pickEvenNumbers(n, block) {
      for(int i = 2; i <= n; i += 2) {
         block(i)
      }
   }
}

3. Closing Thoughts

Closures are very handy tools in Groovy. They help you make your code more concise and modular. But they are not alternatives to regular functions. You will notice  that useful closures would start emerging during refactoring.

Although closures are the derivatives of lambda expressions and Java SE 8 started to support them, closures and lambda expressions are different structures and Java does not support closures yet. For more info regarding their differences you can have a look here.

4. Download The Eclipse Project

This is an example of closure in Groovy.

Download
You can download the full source code of this example as an  Eclipse project here: GroovyClosureExample

Do you want to know how to develop your skillset to become a Java Rockstar?

Subscribe to our newsletter to start Rocking right now!

To get you started we give you our best selling eBooks for FREE!

 

1. JPA Mini Book

2. JVM Troubleshooting Guide

3. JUnit Tutorial for Unit Testing

4. Java Annotations Tutorial

5. Java Interview Questions

6. Spring Interview Questions

7. Android UI Design

 

and many more ....

 

Receive Java & Developer job alerts in your Area

 

Subscribe
Notify of
guest

This site uses Akismet to reduce spam. Learn how your comment data is processed.

1 Comment
Oldest
Newest Most Voted
Inline Feedbacks
View all comments
Rathinavelu
Rathinavelu
1 year ago

Please try {“xx”}() alone and {“xxxx”}() alone ; each works fine ; and then please try {“xx”}() and next line {“xxxx”}() in GroovyConsole.

I get:

groovy> {“xx”}()

groovy> {“xxxx”}()

Exception thrown …