Tutorial

Groovy is a dynamic language which is based on the Java Virtual machine. Groovy supports standard Java constructs including annotations, generics, static imports, enums, varargs and in addition advanced language features as

Groovy is a dynamic language that runs on the JVM and is tightly integrated with the Java language. Groovy provides lots of simplifications compared to standard Java language features and advanced language features as properties, closures, native support for lists, maps and regular expressions, duck typing and the elvis operator.

Groovy is almost compatible to Java, e.g. almost every Java construct is valid Groovy coding which makes the usage of Groovy for an experience Java programmer easy.

The following assumes that you have already Java programming experience and focus on Groovy specific features.

While the simplicity and ease of use is the leading principle of Groovy here are a few nice features of Groovy:

Download the latest version from Groovy from Groovy Homepage.

You have then to set the GROOVY_HOME environment variable and add%GROOVY_HOME%/bin to your path.

Use the Eclipse Update manager to install the Groovy Eclipse plugin. The URL for the update manager is: http://dist.springsource.org/release/GRECLIPSE/e3.6/ for Eclipse 3.6. Select the feature "Groovy-Eclipse".

A Groovy source files ends with the extension .groovy. All Groovy classes are per default public.

Create and run the following groovy class "SumItUp.groovy".

				
package de.vogella.groovy.first

class SumItUp {

static sum(a,b){
	a+b;
	}

static void main(args){
	println sum(1,5)
	println sum(1,2)
	}
}
			

In Groovy all fields of a class have per default the access modifier "private" and Groovy provides automatically getter and setter methods for the fields. Therefore all Groovy classes are per default JavaBeans (Plain Old Java Objects).

You can use the getter and setter directly or use the name of the variable for access. Groovy will convert this to the getter and setter method.

Groovy will also directly create constructors in which you can specify the element you would like to set during construction. Groovy archives this by using the default constructor and then calling the setter methods for the attributes.

Have a look at the following example to see this in action.

				
package de.vogella.groovy.first

public class Person{
	String firstName
	String lastName
	int age
	def address
	
	static void main(def args) {
		Person p = new Person()
		// Use the generated access methods
		p.setFirstName("Lars")
		// This will still use the generated access method, it is not a direct access!
		p.lastName = "Vogel" 
		p.address = ("Homestreet 3");
		println(p.firstName + " " + p.lastName);
		// Use the generated constructor
		p = new Person(firstName: "Peter", lastName:"Mueller");
		println(p.firstName + " " + p.lastName);
	}
	
}

			

One difference between Java and Groovy is that the == operator will check for equality and not for identity. Java checks if both variables points to the same object while Groovy checks if both variables are equals. To check for identify you can use in Groovy the is() method.

Groovy allows to have optional parameter values. Optional parameter values are indicated by =0.

				
class Hello {

static main(args){
	println sum(1,5)
	println sum(1,2,5)
	}

static sum(a,b,c=0){
	a+b+c;
	}
}

			

All variables in Groovy are reference variables (objects), Groovy does not use primitive variables. Groovy still allows to use the primitives types as a short form but always translates this into the object.

Groovy allow static and dynamic typed variables. If you want to use dynamic typed variables you can use the keyword def.

If you use numbers then Groovy will automatically assign a type to it and will also make down- and upcasting for you.

Create the class "TypesTest" to test this.

				
package de.vogella.groovy.datatypes

public class TypesTest{
	public static void main(args){
		int i = 1 // Short form for Integer i = new Integer(1)
		int j = i +3 
		int k = i.plus(3); // Same as above
		// Make sure this worked
		assert(k==4);
		println i.getClass().getName()
		println j.getClass().getName()
		println k.getClass().getName()
		
		// Automatic type assignement
		def value = 1.0F
		println value.getClass().getName()
		def value2 = 1;
		println value2.getClass().getName()
		value2 = value2 / 2;
		println value2
		println value2.getClass().getName()
	}	
	
}

			

Groovy allows to define Strings in '' and in "". Strings which are quoted in by "" are so-called GStrings (short for Groovy Strings). In GStrings you can directly use variables which will then be evaluated and included in the text.

				
package de.vogella.groovy.datatypes

public class StringTesting{
	
	public static void main(String[] args) {
		def name = "John"
		def s1 = "Hello $name" // $name will be replaced
		def s2 = 'Hello $name' // $name will not be replaced
		println s1
		println s2
		println s1.getClass().getName();
		println s2.getClass().getName();
	}
}

			

Groovy treads lists and maps as first class constructs in the language. You define a list via List list = new List[]. You can also use generics. To access element i in a list you can either use list.get(i) or list[i].

				
package de.vogella.groovy.datatypes

public class Person{
	String firstName;
	String lastName;
	Person(String firstName, String lastName){
		this.firstName = firstName
		this.lastName= lastName
	}
}

			

				
package de.vogella.groovy.datatypes

public class ListMapTest{

	public static void main(args){
		List<Integer> list = [1,2,3,4]
		println list[0]
		println list[1]
		println list[2]
		List<Person> persons = list[]
		Person p = new Person("Jim", "Knopf")
		persons[0] = p
		println persons.size()
		println persons[0].firstName
		println persons.get(0).firstName
	}
}

			

You can define maps via Map [key1:value1, key2:value2,...]. An empty map can be created via [:]. The values of a mapped value can get accessed via map[key]. Assignment can be done via map[key]=value.

				
package de.vogella.groovy.datatypes

public class MapTest{
	public static void main(args){
		Map map = [:]
		def map2 = ["Jim":"Knopf", "Thomas":"Edison"]
		println map2["Jim"]
		map2["Test"] = "Tester"
		println map2["Test"]
	}
}

			

Groovy supports ranges. Every object can be used as long as it implements previous() and next() (which are also represented by the ++ and -- operators).

				
package de.vogella.groovy.datatypes

public class RangesTest{
	public static void main(args){
		for (i in 0..9) {
			println ("Hello $i" )
		}
	}
}

			

All fields of a class are per default created private with automatic getter and setter. You can use the getter and setter directly or use the name of the variable for access. Groovy will convert this to the getter and setter method.

Groovy will also directly create constructors in which you can specify the element you would like to set during construction.

				
package de.vogella.groovy.first

public class Person{
	String firstName
	String lastName
	int age
	def address
	
	static void main(def args) {
		Person p = new Person()
		// Use the generated access methods
		p.setFirstName("Lars")
		// This will still use the generated access method, it is not a direct access!
		p.lastName = "Vogel" 
		p.address = ("Homestreet 3");
		println(p.firstName + " " + p.lastName);
		// Use the generated constructor
		p = new Person(firstName: "Peter", lastName:"Mueller");
		println(p.firstName + " " + p.lastName);
	}
	
}

			

You can use safe navigation operator to check safety for null. This will avoid a NullPointerException if you access properties of a variable which is actuall null.

				
// firstName will be null if user is null
// no NPE
def firstName = user?.firstName 

			

The "Elvis operator" is a short form for the Java ternary operator. For example you can use this to set a default if an expression resolves to false or null.

				
// if user exists, return it, otherwise create a new User
user ?: new User()

			

The Groovy shell is the simplest way to run Groovy program. The groovy shell allow you to type in groovy commands and let them evaluate.

Open a command shell (Start-> Run -> cmd under Windows) and start the groovy shell via "groovysh". Type in the following code:

				
 println("Hello Groovy")
			

Press enter-> the system will execute your code.

Start the interactive Groovy Shell with the command groovyConsole. This console allows you to test Groovy code.

You can also complile Groovy code into Java byte-code to use it from Java. To use the byte code the Groovy runtime library must included in the Java classpath.

To create Java bytecode, run the command "groovyc Hello.groovy".

http://groovy.codehaus.org/ Groovy Homepage

http://groovy.codehaus.org/Documentation Groovy documentation

http://grails.codehaus.org Grails Homepage

http://www.ibm.com/developerworks/java/library/j-grails01158/index.html Scott Davis introduction article to Grails

http://www.ibm.com/developerworks/java/library/j-pg04149.html Scott Davis article about loops in Groovy

http://www.ibm.com/developerworks/opensource/library/j-pg05199/index.html Scott Davis about XML processing with Groovy

http://www.ibm.com/developerworks/opensource/library/j-pg06239.html Scott Davis about Metaprogramming