The Groovy programming language is a jvm compatible language that fixes many of Java's shortcomings. Running groovy side by side with your existing Java code is a simple matter of including the groovy jar dependency at runtime even for "enterprise" environments. This is a quick introduction to get your feet wet with this new language. Just enough to feel comfortable with other tools that are based on Groovy, such as the Gradle build system or Grails.

The official documentation on the Groovy website goes into much greater depth. Understanding Java, while not strictly necessary to be productive with Groovy, will help immensely.

Installation

I recommend installing Groovy via the Groovy Version Manager. While you're at it, gvm also provides other tools as well such as the next gen build tool, Gradle.

$ curl -s get.gvmtool.net | bash

$ gvm install groovy

$ gvm install gradle

Running Scripts

After installing groovy, you will have access to the following programs:

groovyConsole - brings up a basic editor that can execute groovy scripts
groovysh - in terminal groovy Read Eval Print Loop (repl)
groovy - groovy interpreter, pass it a script to execute
groovyc - groovy compiler, pass it a script to compile into bytecode, the resulting classes depend on groovy-<version>[-indy].jar (e.g. groovy-2.1.2-indy.jar)
    the indy version of the jar is compiled for versions 1.7+ of the jvm, making use of the new invoke dynamic bytecode instructions for greater performance

Quick Rundown

Many Java programs can be run as Groovy scripts without modification. The Groovy language starts mostly compatible with the Java syntax and removes some of the more cumbersome aspects to make a concise language. Like any scripting language, use these syntactic elements to the level of comfort of those you work with and yourself.

• Parenthesis and semicolons optional
• Common methods like System.out.println can be accessed directly

println "Hello, World"

• Many commonly used packages are automatically imported

	java.io.*

	java.lang.*

	java.math.BigDecimal

	java.math.BigInteger

	java.net.*

	java.util.*

	groovy.lang.*

	groovy.util.*

• Every operator is overloaded to a function call. Where in java you would have to say .equals() for object comparison, we can now say == because it is overloaded to .equals()
• Everything is an object. This includes primitives - they now always use their wrapper types
• Many base types have been extended to provide additional functionality
• Blocks of code delimited by braces {} are treated as closures

4.times {val -> println val}
4.times {println it} //equivalent, implicit closure variable 'it' is always defined for us inside of a closure

• Brackets [] are interpreted in a more dynamic manner and can be used for Sets, Lists, Arrays, and Maps. What you assign a bracketed expression to will determine its type:

List mylist = [1,1,2,3] // results in an ArrayList containing all elements listed
Set myset = [1,1,2,3] // results in a HashSet containing only [1,2,3]
Map mypet = ["type":"parrot", "name": "polly", "color": "green"]

//LinkedHashMap

• Strings allow for inline substitution of arbitrary code:

"The current time is: ${new Date()}"

• Type declarations are optional, however there are some interesting cases surrounding scope binding and type declaration.
• Inside methods, the last line to get executed is automatically returned
• Map based constructors
• Automatic, overridable accessors (get/set), properties explicitly marked as private do not generate accessors automatically
• Default private scope (package scope on the rare occasion it is needed, is made accessible via an annotation)
• Interfaces defining only one method can be anonymously constructed with closures and the as keyword:
• New annotations to automatically construct common code such as toString()

import groovy.transform.*;

@ToString
class Foo {
  def value
}

def ary = [new Foo(value: 8), new Foo(value: 1), new Foo (value: 4), new Foo(value: 2)]
Collections.sort(ary, {lhs, rhs -> lhs.value - rhs.value} as Comparator)
println ary

Breaking Changes

Most of the breaking changes to the Java language come from the dynamic nature of how brackets and braces are now interpreted.
Namely inline array initialization:

int[] ary = new int[] {1,2,3}

is now broken, but replaced by the simpler to understand:

def ary = [1,2,3]