Single-line comments start with// and can be found at any position in the line.The characters following//, until the end of the line, are considered part of the comment.

A multiline comment starts with/* and can be found at any position in the line.The characters following/* will be considered part of the comment, including new line characters,up to the first*/ closing the comment.Multiline comments can thus be put at the end of a statement, or even inside a statement.

Similarly to multiline comments, Groovydoc comments are multiline, but start with/** and end with*/.Lines following the first Groovydoc comment line can optionally start with a star*.Those comments are associated with:

• type definitions (classes, interfaces, enums, annotations),

• fields and properties definitions

• methods definitions

Although the compiler will not complain about Groovydoc comments not being associated with the above language elements,you should prepend those constructs with the comment right before it.

Groovydoc follows the same conventions as Java’s own Javadoc.So you’ll be able to use the same tags as with Javadoc.

In addition, Groovy supportsRuntime Groovydoc since 3.0.0, i.e. Groovydoc can be retained at runtime.

The Runtime Groovydoc starts with/**@ and ends with*/, for example:

Beside the single-line comment, there is a special line comment, often called theshebang line understood by UNIX systemswhich allows scripts to be run directly from the command-line, provided you have installed the Groovy distributionand thegroovy command is available on thePATH.

Identifiers start with a letter, a dollar or an underscore.They cannot start with a number.

A letter can be in the following ranges:

• 'a' to 'z' (lowercase ascii letter)

• 'A' to 'Z' (uppercase ascii letter)

• '\u00C0' to '\u00D6'

• '\u00D8' to '\u00F6'

• '\u00F8' to '\u00FF'

• '\u0100' to '\uFFFE'

Then following characters can contain letters and numbers.

Here are a few examples of valid identifiers (here, variable names):

But the following ones are invalid identifiers:

All keywords are also valid identifiers when following a dot:

Quoted identifiers appear after the dot of a dotted expression.For instance, thename part of theperson.name expression can be quoted withperson."name" orperson.'name'.This is particularly interesting when certain identifiers contain illegal characters that are forbidden by the Java Language Specification,but which are allowed by Groovy when quoted. For example, characters like a dash, a space, an exclamation mark, etc.

As we shall see in thefollowing section on strings, Groovy provides different string literals.All kind of strings are actually allowed after the dot:

There’s a difference between plain character strings and Groovy’s GStrings (interpolated strings),as in that the latter case, the interpolated values are inserted in the final string for evaluating the whole identifier:

Single-quoted strings are a series of characters surrounded by single quotes:

All the Groovy strings can be concatenated with the+ operator:

Triple-single-quoted strings are a series of characters surrounded by triplets of single quotes:

Triple-single-quoted strings may span multiple lines.The content of the string can cross line boundaries without the need to split the string in several piecesand without concatenation or newline escape characters:

If your code is indented, for example in the body of the method of a class, your string will contain the whitespace of the indentation.The Groovy Development Kit contains methods for stripping out the indentation with theString#stripIndent() method,and with theString#stripMargin() method that takes a delimiter character to identify the text to remove from the beginning of a string.

When creating a string as follows:

You will notice that the resulting string contains a newline character as first character.It is possible to strip that character by escaping the newline with a backslash:

Escaping special characters

'an escaped single quote: \' needs a backslash'

'an escaped escape character: \\ needs a double backslash'

Unicode escape sequence

'The Euro currency symbol: \u20AC'

Double-quoted strings are a series of characters surrounded by double quotes:

String interpolation

def name = 'Guillaume' // a plain stringdef greeting = "Hello ${name}"assert greeting.toString() == 'Hello Guillaume'

def sum = "The sum of 2 and 3 equals ${2 + 3}"assert sum.toString() == 'The sum of 2 and 3 equals 5'

def person = [name: 'Guillaume', age: 36]assert "$person.name is $person.age years old" == 'Guillaume is 36 years old'

def number = 3.14

shouldFail(MissingPropertyException) {    println "$number.toString()"}

String thing = 'treasure'assert 'The x-coordinate of the treasure is represented by treasure.x' ==    "The x-coordinate of the $thing is represented by $thing.x"   // <= Not allowed: ambiguous!!assert 'The x-coordinate of the treasure is represented by treasure.x' ==        "The x-coordinate of the $thing is represented by ${thing}.x"  // <= Curly braces required

assert '$5' == "\$5"assert '${name}' == "\${name}"

Special case of interpolating closure expressions

def sParameterLessClosure = "1 + 2 == ${-> 3}"(1)assert sParameterLessClosure == '1 + 2 == 3'def sOneParamClosure = "1 + 2 == ${ w -> w << 3}"(2)assert sOneParamClosure == '1 + 2 == 3'

def number = 1(1)def eagerGString = "value == ${number}"def lazyGString = "value == ${ -> number }"assert eagerGString == "value == 1"(2)assert lazyGString ==  "value == 1"(3)number = 2(4)assert eagerGString == "value == 1"(5)assert lazyGString ==  "value == 2"(6)

Interoperability with Java

String takeString(String message) {(4)    assert message instanceof String(5)    return message}def message = "The message is ${'hello'}"(1)assert message instanceof GString(2)def result = takeString(message)(3)assert result instanceof Stringassert result == 'The message is hello'

GString and String hashCodes

assert "one: ${1}".hashCode() != "one: 1".hashCode()

def key = "a"def m = ["${key}": "letter ${key}"](1)assert m["a"] == null(2)

Triple-double-quoted strings behave like double-quoted strings, with the addition that they are multiline, like the triple-single-quoted strings.

Beyond the usual quoted strings, Groovy offers slashy strings, which use/ as the opening and closing delimiter.Slashy strings are particularly useful for defining regular expressions and patterns,as there is no need to escape backslashes.

Example of a slashy string:

Only forward slashes need to be escaped with a backslash:

Slashy strings are multiline:

Slashy strings can be thought of as just another way to define a GString but with different escaping rules. They hence support interpolation:

Special cases

assert '' == //

Dollar slashy strings are multiline GStrings delimited with an opening$/ and a closing/$.The escaping character is the dollar sign, and it can escape another dollar, or a forward slash.Escaping for the dollar and forward slash characters is only needed where conflicts arise withthe special use of those characters. The characters$foo would normally indicate a GStringplaceholder, so those four characters can be entered into a dollar slashy string by escaping the dollar, i.e.$$foo.Similarly, you will need to escape a dollar slashy closing delimiter if you want it to appear in your string.

Here are a few examples:

It was created to overcome some of the limitations of the slashy string escaping rules.Use it when its escaping rules suit your string contents (typically if it has some slashes you don’t want to escape).

Unlike Java, Groovy doesn’t have an explicit character literal.However, you can be explicit about making a Groovy string an actual character, by three different means:

The integral literal types are the same as in Java:

• byte

• char

• short

• int

• long

• java.math.BigInteger

You can create integral numbers of those types with the following declarations:

If you use optional typing by using thedef keyword, the type of the integral number will vary:it’ll adapt to the capacity of the type that can hold that number.

For positive numbers:

As well as for negative numbers:

Alternative non-base 10 representations

int xInt = 0b10101111assert xInt == 175short xShort = 0b11001001assert xShort == 201 as shortbyte xByte = 0b11assert xByte == 3 as bytelong xLong = 0b101101101101assert xLong == 2925lBigInteger xBigInteger = 0b111100100001assert xBigInteger == 3873gint xNegativeInt = -0b10101111assert xNegativeInt == -175

int xInt = 077assert xInt == 63short xShort = 011assert xShort == 9 as shortbyte xByte = 032assert xByte == 26 as bytelong xLong = 0246assert xLong == 166lBigInteger xBigInteger = 01111assert xBigInteger == 585gint xNegativeInt = -077assert xNegativeInt == -63

int xInt = 0x77assert xInt == 119short xShort = 0xaaassert xShort == 170 as shortbyte xByte = 0x3aassert xByte == 58 as bytelong xLong = 0xffffassert xLong == 65535lBigInteger xBigInteger = 0xaaaaassert xBigInteger == 43690gDouble xDouble = new Double('0x1.0p0')assert xDouble == 1.0dint xNegativeInt = -0x77assert xNegativeInt == -119

The decimal literal types are the same as in Java:

• float

• double

• java.math.BigDecimal

You can create decimal numbers of those types with the following declarations:

Decimals can use exponents, with thee orE exponent letter, followed by an optional sign,and an integral number representing the exponent:

Conveniently for exact decimal number calculations, Groovy choosesjava.math.BigDecimal as its decimal number type.In addition, bothfloat anddouble are supported, but require an explicit type declaration, type coercion or suffix.Even ifBigDecimal is the default for decimal numbers, such literals are accepted in methods or closures takingfloat ordouble as parameter types.

When writing long literal numbers, it’s harder on the eye to figure out how some numbers are grouped together, for example with groups of thousands, of words, etc. By allowing you to place underscore in number literals, it’s easier to spot those groups:

We can force a number (including binary, octals and hexadecimals) to have a specific type by giving a suffix (see table below), either uppercase or lowercase.

Examples:

Althoughoperators are covered in more detail elsewhere, it’s important to discuss the behavior of math operationsand what their resulting types are.

Division and power binary operations aside (covered below),

• binary operations betweenbyte,char,short andint result inint

• binary operations involvinglong withbyte,char,short andint result inlong

• binary operations involvingBigInteger and any other integral type result inBigInteger

• binary operations involvingBigDecimal withbyte,char,short,int andBigInteger result inBigDecimal

• binary operations betweenfloat,double andBigDecimal result indouble

• binary operations between twoBigDecimal result inBigDecimal

The following table summarizes those rules:

The case of the division operator

The case of the power operator

// base and exponent are ints and the result can be represented by an Integerassert    2    **   3    instanceof Integer    //  8assert   10    **   9    instanceof Integer    //  1_000_000_000// the base is a long, so fit the result in a Long// (although it could have fit in an Integer)assert    5L   **   2    instanceof Long       //  25// the result can't be represented as an Integer or Long, so return a BigIntegerassert  100    **  10    instanceof BigInteger //  10e20assert 1234    ** 123    instanceof BigInteger //  170515806212727042875...// the base is a BigDecimal and the exponent a negative int// but the result can be represented as an Integerassert    0.5  **  -2    instanceof Integer    //  4// the base is an int, and the exponent a negative float// but again, the result can be represented as an Integerassert    1    **  -0.3f instanceof Integer    //  1// the base is an int, and the exponent a negative int// but the result will be calculated as a Double// (both base and exponent are actually converted to doubles)assert   10    **  -1    instanceof Double     //  0.1// the base is a BigDecimal, and the exponent is an int, so return a BigDecimalassert    1.2  **  10    instanceof BigDecimal //  6.1917364224// the base is a float or double, and the exponent is an int// but the result can only be represented as a Double valueassert    3.4f **   5    instanceof Double     //  454.35430372146965assert    5.6d **   2    instanceof Double     //  31.359999999999996// the exponent is a decimal value// and the result can only be represented as a Double valueassert    7.8  **   1.9  instanceof Double     //  49.542708423868476assert    2    **   0.1f instanceof Double     //  1.0717734636432956

def myBooleanVariable = trueboolean untypedBooleanVar = falsebooleanField = true

def numbers = [1, 2, 3](1)assert numbers instanceof List(2)assert numbers.size() == 3(3)

def heterogeneous = [1, "a", true](1)

def arrayList = [1, 2, 3]assert arrayList instanceof java.util.ArrayListdef linkedList = [2, 3, 4] as LinkedList(1)assert linkedList instanceof java.util.LinkedListLinkedList otherLinked = [3, 4, 5](2)assert otherLinked instanceof java.util.LinkedList

def letters = ['a', 'b', 'c', 'd']assert letters[0] == 'a'(1)assert letters[1] == 'b'assert letters[-1] == 'd'(2)assert letters[-2] == 'c'letters[2] = 'C'(3)assert letters[2] == 'C'letters << 'e'(4)assert letters[ 4] == 'e'assert letters[-1] == 'e'assert letters[1, 3] == ['b', 'd'](5)assert letters[2..4] == ['C', 'd', 'e'](6)

def multi = [[0, 1], [2, 3]](1)assert multi[1][0] == 2(2)

String[] arrStr = ['Ananas', 'Banana', 'Kiwi'](1)assert arrStr instanceof String[](2)assert !(arrStr instanceof List)def numArr = [1, 2, 3] as int[](3)assert numArr instanceof int[](4)assert numArr.size() == 3

def matrix3 = new Integer[3][3](1)assert matrix3.size() == 3Integer[][] matrix2(2)matrix2 = [[1, 2], [3, 4]]assert matrix2 instanceof Integer[][]

String[] names = ['Cédric', 'Guillaume', 'Jochen', 'Paul']assert names[0] == 'Cédric'(1)names[2] = 'Blackdrag'(2)assert names[2] == 'Blackdrag'

Groovy has always supported literal list/array definitions using square bracketsand has avoided Java-style curly braces so as not to conflict with closure definitions.In the case where the curly braces come immediately after an array type declaration however,there is no ambiguity with closure definitions,so Groovy 3 and above support that variant of the Java array initialization expression.

Examples:

def colors = [red: '#FF0000', green: '#00FF00', blue: '#0000FF'](1)assert colors['red'] == '#FF0000'(2)assert colors.green  == '#00FF00'(3)colors['pink'] = '#FF00FF'(4)colors.yellow  = '#FFFF00'(5)assert colors.pink == '#FF00FF'assert colors['yellow'] == '#FFFF00'assert colors instanceof java.util.LinkedHashMap

assert colors.unknown == nulldef emptyMap = [:]assert emptyMap.anyKey == null

def numbers = [1: 'one', 2: 'two']assert numbers[1] == 'one'

def key = 'name'def person = [key: 'Guillaume'](1)assert !person.containsKey('name')(2)assert person.containsKey('key')(3)

person = [(key): 'Guillaume'](1)assert person.containsKey('name')(2)assert !person.containsKey('key')(3)

The following binary arithmetic operators are available in Groovy:

Here are a few examples of usage of those operators:

The+ and- operators are also available as unary operators:

In terms of unary arithmetics operators, the++ (increment) and-- (decrement) operators are available,both in prefix and postfix notation:

For the unary not operator on Booleans, seeConditional operators.

The binary arithmetic operators we have seen above are also available in an assignment form:

• +=

• -=

• *=

• /=

• %=

• **=

Let’s see them in action:

assert 1 + 2 == 3assert 3 != 4assert -2 < 3assert 2 <= 2assert 3 <= 4assert 5 > 1assert 5 >= -2

import groovy.transform.EqualsAndHashCode@EqualsAndHashCodeclass Creature { String type }def cat = new Creature(type: 'cat')def copyCat = catdef lion = new Creature(type: 'cat')assert cat.equals(lion) // Java logical equalityassert cat == lion      // Groovy shorthand operatorassert cat.is(copyCat)  // Groovy identityassert cat === copyCat  // operator shorthandassert cat !== lion     // negated operator shorthand

assert !false(1)assert true && true(2)assert true || false(3)

The logical "not" has a higher priority than the logical "and".

The logical "and" has a higher priority than the logical "or".

The logical|| operator supports short-circuiting: if the left operand is true, it knows that the result will be true in any case, so it won’t evaluate the right operand.The right operand will be evaluated only if the left operand is false.

Likewise for the logical&& operator: if the left operand is false, it knows that the result will be false in any case, so it won’t evaluate the right operand.The right operand will be evaluated only if the left operand is true.

Groovy offers four bitwise operators:

• &: bitwise "and"

• |: bitwise "or"

• ^: bitwise "xor" (exclusive "or")

• ~: bitwise negation

Bitwise operators can be applied on arguments which are of typebyte,short,int,long, orBigInteger.If one of the arguments is aBigInteger, the result will be of typeBigInteger;otherwise, if one of the arguments is along, the result will be of typelong;otherwise, the result will be of typeint:

It’s worth noting that the internal representation of primitive types follow theJava Language Specification. In particular,primitive types are signed, meaning that for a bitwise negation, it is always good to use a mask to retrieve only the necessary bits.

In Groovy, bitwise operators areoverloadable, meaning that you can define the behavior of those operators for any kind of object.

Groovy offers three bit shift operators:

• <<: left shift

• >>: right shift

• >>>: right shift unsigned

All three operators are applicable where the left argument is of typebyte,short,int, orlong.The first two operators can also be applied where the left argument is of typeBigInteger.If the left argument is aBigInteger, the result will be of typeBigInteger;otherwise, if the left argument is along, the result will be of typelong;otherwise, the result will be of typeint:

In Groovy, bit shift operators areoverloadable, meaning that you can define the behavior of those operators for any kind of object.

The "not" operator is represented with an exclamation mark (!) and inverts the result of the underlying boolean expression. Inparticular, it is possible to combine thenot operator with theGroovy truth:

The ternary operator is a shortcut expression that is equivalent to an if/else branch assigning some value to a variable.

Instead of:

You can write:

The ternary operator is also compatible with theGroovy truth, so you can make it even simpler:

The "Elvis operator" is a shortening of the ternary operator. One instance of where this is handy is for returninga 'sensible default' value if an expression resolves tofalse-ish (as inGroovy truth). A simple example might look like this:

Usage of the Elvis operator reduces the verbosity of your code and reduces the risks of errors in case of refactorings,by removing the need to duplicate the expression which is tested in both the condition and the positive return value.

Groovy 3.0.0 introduces the Elvis operator, for example:

The Safe Navigation operator is used to avoid aNullPointerException. Typically when you have a reference to an objectyou might need to verify that it is notnull before accessing methods or properties of the object. To avoid this, the safenavigation operator will simply returnnull instead of throwing an exception, like so:

Normally in Groovy, when you write code like this:

Theuser.name call triggers a call to the property of the same name, that is to say, here, to the getter forname. Ifyou want to retrieve the field instead of calling the getter, you can use the direct field access operator:

The method pointer operator (.&) can be used to store a reference to a method in a variable,in order to call it later:

There are multiple advantages in using method pointers. First of all, the type of such a method pointer isagroovy.lang.Closure, so it can be used in any place a closure would be used. In particular, it is suitable toconvert an existing method for the needs of the strategy pattern:

Method pointers are bound by the receiver and a method name. Arguments are resolved at runtime, meaning that if you havemultiple methods with the same name, the syntax is not different, only resolution of the appropriate method to be calledwill be done at runtime:

To align with Java 8 method reference expectations, in Groovy 3 and above, you can usenew as themethod name to obtain a method pointer to the constructor:

Also in Groovy 3 and above, you can obtain a method pointer to an instance method of a class.This method pointer takes an additional parameter being the receiver instance toinvoke the method on:

For backwards compatibility, any static methods that happen to have the correctparameters for the call will be given precedence over instance methods for this case.

The Parrot parser in Groovy 3+ supports the Java 8+ method reference operator.The method reference operator (::) can be used to reference a method or constructorin contexts expecting a functional interface. This overlaps somewhat with the functionalityprovided by Groovy’s method pointer operator. Indeed, for dynamic Groovy, the methodreference operator is just an alias for the method pointer operator.For static Groovy, the operator results in bytecode similar to the bytecodethat Java would produce for the same context.

Some examples highlighting various supported method reference cases are shown in the following script:

Some examples highlighting various supported constructor reference cases are shown in the following script:

The pattern operator (~) provides a simple way to create ajava.util.regex.Pattern instance:

while in general, you find the pattern operator with an expression in a slashy-string, it can be used with any kind ofString in Groovy:

Alternatively to building a pattern, you can use the find operator=~ to directly create ajava.util.regex.Matcher instance:

Since aMatcher coerces to aboolean by calling itsfind method, the=~ operator is consistent with the simpleuse of Perl’s=~ operator, when it appears as a predicate (inif,?:, etc.). When the intent is to iterate overmatches of the specified pattern (inwhile, etc.) callfind() directly on the matcher or use theiterator DGM.

The match operator (==~) is a slight variation of the find operator, that does not return aMatcher but a booleanand requires a strict match of the input string:

Typically, the match operator is used when the pattern involves a single exact match, otherwisethe find operator might be more useful.

The Spread-dot Operator (*.), often abbreviated to just Spread Operator, is used to invoke an action on all itemsof an aggregate object. It is equivalent to calling the action on each item and collecting the result into a list:

The expressioncars*.make is equivalent tocars.collect{ it.make }.Groovy’s GPath notation allows a short-cut when the referenced propertyisn’t a property of the containing list, in that case it is automaticallyspread. In the previously mentioned case, the expressioncars.make canbe used, though retaining the explicit spread-dot operator is often recommended.

The spread operator is null-safe, meaning that if an element of the collection is null,it will return null instead of throwing aNullPointerException:

The spread operator can be used on any class which implements theIterable interface:

Use multiple invocations of the spread-dot operator (herecars*.models*.name) whenworking with aggregates of data structures which themselves contain aggregates:

Consider using thecollectNested DGM method instead of the spread-dot operator for collections of collections:

Spreading method arguments

int function(int x, int y, int z) {    x*y+z}

def args = [4,5,6]

assert function(*args) == 26

args = [4]assert function(*args,5,6) == 26

Spread list elements

def items = [4,5](1)def list = [1,2,3,*items,6](2)assert list == [1,2,3,4,5,6](3)

Spread map elements

def m1 = [c:3, d:4](1)def map = [a:1, b:2, *:m1](2)assert map == [a:1, b:2, c:3, d:4](3)

def m1 = [c:3, d:4](1)def map = [a:1, b:2, *:m1, d: 8](2)assert map == [a:1, b:2, c:3, d:8](3)

Groovy supports the concept of ranges and provides a notation (..) to create ranges of objects:

Ranges implementation is lightweight, meaning that only the lower and upper bounds are stored. You can create a rangefrom anyComparable object that hasnext() andprevious() methods to determine the next / previous item in the range.For example, you can create a range of characters this way:

The spaceship operator (<=>) delegates to thecompareTo method:

The subscript operator is a shorthand notation forgetAt orputAt, depending on whether you find it onthe left hand side or the right hand side of an assignment:

The subscript operator, in combination with a custom implementation ofgetAt/putAt is a convenient way for destructuringobjects:

Groovy 3.0.0 introduces safe indexing operator, i.e.?[], which is similar to?.. For example:

The membership operator (in) is equivalent to calling theisCase method. In the context of aList, it is equivalentto callingcontains, like in the following example:

In Groovy, using== to test equality is different from using the same operator in Java. In Groovy, it is callingequals.If you want to compare reference equality, you should useis like in the following example:

The coercion operator (as) is a variant of casting. Coercion converts object from one type to anotherwithout thembeing compatible for assignment. Let’s take an example:

This can be fixed by usingcoercion instead:

When an object is coerced into another, unless the target type is the same as the source type, coercion will return anew object. The rules of coercion differ depending on the source and target types, and coercion may fail if no conversionrules are found. Custom conversion rules may be implemented thanks to theasType method:

The diamond operator (<>) is a syntactic sugar only operator added to support compatibility with the operator of thesame name in Java 7. It is used to indicate that generic types should be inferred from the declaration:

In dynamic Groovy, this is totally unused. In statically type checked Groovy, it is also optional since the Groovytype checker performs type inference whether this operator is present or not.

The call operator() is used to call a method namedcall implicitly. For any object which defines acall method, you can omit the.call part and use the call operator instead:

class Bucket {    int size    Bucket(int size) { this.size = size }    Bucket plus(Bucket other) {(1)        return new Bucket(this.size + other.size)    }}

def b1 = new Bucket(4)def b2 = new Bucket(11)assert (b1 + b2).size == 15(1)

assert (b1 + 11).size == 15

Bucket plus(int capacity) {    return new Bucket(this.size + capacity)}

// defining a package named com.yoursitepackage com.yoursite

// importing the class MarkupBuilderimport groovy.xml.MarkupBuilder// using the imported class to create an objectdef xml = new MarkupBuilder()assert xml != null

Default imports are the imports that Groovy language provides by default. For example look at the following code:

The same code in Java needs an import statement toDate class like this: import java.util.Date. Groovy by default imports these classes for you.

The below imports are added by groovy for you:

This is done because the classes from these packages are most commonly used. By importing these boilerplate code is reduced.

A simple import is an import statement where you fully define the class name along with the package. For example the import statement import groovy.xml.MarkupBuilder in the code below is a simple import which directly refers to a class inside a package.

Groovy, like Java, provides a special way to import all classes from a package using*, the so-called star import.MarkupBuilder is a class which is in packagegroovy.xml, alongside another class calledStreamingMarkupBuilder. In case you need to use both classes, you can do:

That’s perfectly valid code. But with a* import, we can achieve the same effect with just one line. The star imports all the classes under packagegroovy.xml:

One problem with* imports is that they can clutter your local namespace. But with the kinds of aliasing provided by Groovy, this can be solved easily.

Groovy’s static import capability allows you to reference imported classes as if they were static methods in your own class:

This is similar to Java’s static import capability but is a more dynamic than Java in that it allows you to define methods with the same name as an imported method as long as you have different types:

If you have the same types, the imported class takes precedence.

Static imports with theas keyword provide an elegant solution to namespace problems. Suppose you want to get aCalendar instance, using itsgetInstance() method. It’s a static method, so we can use a static import. But instead of callinggetInstance() every time, which can be misleading when separated from its class name, we can import it with an alias, to increase code readability:

Now, that’s clean!

A static star import is very similar to the regular star import. It will import all the static methods from the given class.

For example, lets say we need to calculate sines and cosines for our application.The classjava.lang.Math has static methods namedsin andcos which fit our need. With the help of a static star import, we can do:

As you can see, we were able to access the methodssin andcos directly, without theMath. prefix.

With type aliasing, we can refer to a fully qualified class name using a name of our choice. This can be done with theas keyword, as before.

For example we can importjava.sql.Date asSQLDate and use it in the same file asjava.util.Date without having to use the fully qualified name of either class:

Groovy supports both scripts and classes. Take the following code for example:

This is typical code that you would find coming from Java, where codehas to be embedded into a class to be executable.Groovy makes it easier, the following code is equivalent:

A script can be considered as a class without needing to declare it, with some differences.

Agroovy.lang.Script is always compiled into a class. The Groovy compiler will compile the class for you,with the body of the script copied into arun method. The previous example is therefore compiled as if it was thefollowing:

If the script is in a file, then the base name of the file is used to determine the name of the generated script class.In this example, if the name of the file isMain.groovy, then the script class is going to beMain.

It is possible to define methods into a script, as illustrated here:

You can also mix methods and code. The generated script class will carry all methods into the script class, andassemble all script bodies into therun method:

This code is internally converted into:

Variables in a script do not require a type definition. This means that this script:

will behave the same as:

However, there is a semantic difference between the two:

• if the variable is declared as in the first example, it is alocal variable. It will be declared in therunmethod that the compiler will generate and willnot be visible outside of the script main body. In particular, sucha variable willnot be visible in other methods of the script

• if the variable is undeclared, it goes into thegroovy.lang.Script#getBinding(). The binding isvisible from the methods, and is especially important if you use a script to interact with an application and need toshare data between the script and the application. Readers might refer to theintegration guide for more information.

Groovy supports the same primitive types as defined by theJava Language Specification:

• integral types:byte (8 bit),short (16 bit),int (32 bit) andlong (64 bit)

• floating-point types:float (32 bit) anddouble (64 bit)

• theboolean type (one oftrue orfalse)

• thechar type (16 bit, usable as a numeric type, representing a UTF-16 code)

Also like Java, Groovy uses the respective wrapper classes when objects corresponding to anyof the primitive types are required:

Automatic boxing and unboxing occur when, for instance, calling a method requiringthe wrapper class and passing it a primitive variable as the parameter, or vice-versa.This is similar to Java but Groovy takes the idea further.

In most scenarios, you can treat a primitive just like it was the full object wrapper equivalent.For instance, you can call.toString() or.equals(other) on a primitive.Groovy autowraps and unwraps between references and primitives as needed.

Here’s an example usingint which is declared as a static field in a class (discussed shortly):

Now you may be concerned that this means every time you use a mathematical operator on a reference to a primitivethat you’ll incur the cost of unboxing and reboxing the primitive. But this is not the case, as Groovy will compileyour operators into theirmethod equivalents and uses those instead.Additionally, Groovy will automatically unbox to a primitive when calling a Java method that takes a primitiveparameter and automatically box primitive method return values from Java. However, be aware there are somedifferences from Java’s method resolution.

Apart from primitives, everything else is an object and has an associated class defining its type.We’ll discuss classes, and class-related or class-like things like interfaces, traits and records shortly.

We might declare two variables, of type String and List, as follows:

Groovy carries across the same concepts with regard to generics as Java.When defining classes and methods, it is possible to use a type parameter and createa generic class, interface, method or constructor.

Usage of generic classes and methods, regardless of whether they are defined in Javaor Groovy, may involve supplying a type argument.

We might declare a variable, of type"list of string", as follows:

Java employs type erasure for backwards compatibility with earlier versions of Java.Dynamic Groovy can be thought of as more aggressively applying type erasure.In general, less generics type information will be checked at compile time.Groovy’s static nature employs similar checks to Java with regard to generics information.

class Person {(1)    String name(2)    Integer age    def increaseAge(Integer years) {(3)        this.age += years    }}

Normal classes refer to classes which are top level and concrete. This means they can be instantiated without restrictions from any other classes or scripts. This way, they can only be public (even though thepublic keyword may be suppressed). Classes are instantiated by calling their constructors, using thenew keyword, as in the following snippet.

Inner classes are defined within another classes. The enclosing class can use the inner class as usual. On the other side, an inner class can access members of its enclosing class, even if they are private. Classes other than the enclosing class are not allowed to access inner classes. Here is an example:

There are some reasons for using inner classes:

• They increase encapsulation by hiding the inner class from other classes, which do not need to know about it. This also leads to cleaner packages and workspaces.

• They provide a good organization, by grouping classes that are used by only one class.

• They lead to more maintainable codes, since inner classes are near the classes that use them.

It is common for an inner class to be an implementation of some interface whose method(s) are needed by the outer class.The code below illustrates this typical usage pattern, here being used with threads.

Note that the classInner2 is defined only to provide an implementation of the methodrun to classOuter2.Anonymous inner classes help to eliminate verbosity in this case.That topic is covered shortly.

Groovy 3+ also supports Java syntax for non-static inner class instantiation, for example:

Anonymous inner class

class Outer3 {    private String privateStr = 'some string'    def startThread() {        new Thread(new Runnable() {(1)            void run() {                println "${privateStr}."            }        }).start()(2)    }}

Abstract class

abstract class Abstract {(1)    String name    abstract def abstractMethod()(2)    def concreteMethod() {        println 'concrete'    }}

Inheritance in Groovy resembles inheritance in Java.It provides a mechanism for a child class (or subclass) to reusecode or properties from a parent (or super class).Classes related through inheritance form an inheritance hierarchy.Common behavior and members are pushed up the hierarchy to reduce duplication.Specializations occur in child classes.

Different forms of inheritance are supported:

• implementation inheritance where code (methods, fields or properties) from asuperclass or fromone or moretraits is reused by a child class

• contract inheritance where a class promises to provide particular abstract methods defined in asuperclass,or defined in one or moretraits orinterfaces.

Parent classes share visible fields, properties or methods with child classes.A child class may have at most one parent class.Theextends keyword is used immediately prior to giving the superclass type.

An interface defines a contract that a class needs to conform to.An interface only defines a list of methods that needto be implemented, but does not define the method’s implementation.

Methods of an interface are alwayspublic. It is an error to useprotected orprivate methods in interfaces:

A classimplements an interface if it defines the interface in itsimplements list or if any of its superclassesdoes: