Groovy Syntax Basics

Groovy syntax is best understood as a superset of Java conventions with several pieces of ceremony made optional. Semicolons at the end of statements are optional (though still legal), parentheses around a method's final argument can be dropped when that argument is a closure - which is why list.each { it } reads more naturally than list.each({ it }) - and the return keyword is optional in methods and closures, since Groovy implicitly returns the value of the last expression evaluated. None of this changes what runs on the JVM underneath; it simply removes syntactic noise that Java requires for the compiler's benefit, letting Groovy code read closer to pseudocode while still being fully valid, compilable code.

Groovy variables can be declared with the def keyword, which tells the compiler to infer the type dynamically rather than requiring an explicit one - def count = 5 behaves differently from Java's int count = 5 in that count could later be reassigned to hold a String or a List without a compile error. You can still use explicit types exactly as in Java (String name = "Amit", int total = 0), and doing so gives you compile-time type checking exactly like Java would. The final keyword works the same way it does in Java, preventing reassignment once a value is set, and it combines naturally with def as final def CONFIG = loadConfig() when you want runtime-inferred typing but a guarantee the reference won't change.

Groovy distinguishes between plain single-quoted strings, which behave exactly like Java String literals with no special processing, and double-quoted GStrings, which support inline interpolation with ${expression} (or the shorthand $variable for simple identifiers). This means "Total: ${price * quantity}" evaluates the expression inside the braces and embeds the result directly into the string, eliminating the need for String.format or repeated + concatenation that Java requires. Groovy also supports triple-quoted strings ('''...''' or """...""") for multi-line text, which is especially useful for embedding SQL queries or multi-line templates directly in a script without manual line-break escaping.

Groovy gives lists and maps first-class literal syntax: def scores = [90, 85, 78] creates a List (backed by java.util.ArrayList by default) with no constructor call needed, and def player = [name: "Kohli", runs: 82] creates a Map (backed by LinkedHashMap) using colon-separated key-value pairs. Both types come with a rich set of built-in methods beyond what java.util offers directly - each iterates with a closure, collect transforms each element into a new list, and findAll filters elements matching a closure's condition - all without importing streams or writing verbose loop boilerplate. This collection-literal syntax, combined with closures, is what makes Groovy code for data manipulation noticeably shorter than equivalent Java using explicit ArrayList and HashMap construction.

A closure in Groovy is a block of code enclosed in { } that can be assigned to a variable, passed as a method argument, and invoked later with () or .call(). Closures are genuinely first-class objects of type groovy.lang.Closure, capturing the variables in scope at the point they were defined, which is what lets def multiplier = { int x -> x * 2 } be stored, passed around, and invoked as multiplier(5) anywhere in the program. When a closure takes exactly one parameter, Groovy lets you omit the parameter name entirely and refer to it with the implicit variable it, which is why numbers.each { println it } is idiomatic Groovy rather than the more explicit numbers.each { n -> println n }.