Groovy, being a Java-like language written for the Java platform, shares most of its keywords with Java. However, Groovy introduces a few additional keywords of its own. In this post, we’ll explore these new keywords that have been introduced in Groovy.
There are 4 keywords in addition to what Java provides. They are:
- def
- as
- in
- trait
def
def is Groovy’s way of declaring a variable, method, or method parameter without specifying an explicit type. Under the hood, it maps to java.lang.Object, but its real purpose is to signal that you’re opting into Groovy’s dynamic typing — letting the runtime figure out the type for you.
def does not mean untyped, it means the type is determined at runtime.
This is by far the most used keyword in Groovy, as we use it in many places, from declaring variables to specifying return types for methods. It makes things pretty easy for us by eliminating the need for long, verbose type declarations.
def name = "Shiva" // Inferred as String
def height = 170 // Inferred as Integer
def shoppingList = ["Notebooks", "Pen", "Clips"] // Inferred as ArrayList
You can also use def for method declarations where the return type is not specified:
def greet(name) {
"Hello, $name!" // Groovy returns the last expression automatically
}
println greet("Shiva") // Hello, Shiva!
One important thing to remember: in a script context, declaring a variable with def makes it local, while declaring it without def puts it into the script’s binding (making it globally accessible).
x = 10 // Binding variable — accessible across methods in the script
def y = 20 // Local variable — only accessible in this scope
as
as is also one of the most used keywords in Groovy. It serves two important purposes:
- Type coercion — converting one type to another
- Import aliasing — renaming imports to avoid conflicts or improve readability
More than that, it makes code more readable — it clearly conveys that you are trying to convert something or create an alias, without the complicated bracket syntax that Java requires.
1. Type Coercion (Casting)
The most common use converting a value from one type to another:
// String to Number
def num = "42" as Integer // 42
def decimal = "3.14" as Double // 3.14
def big = "1000" as BigDecimal // 1000
// Number to String
def text = 123 as String // "123"
// Number type conversions
def i = 3.14 as Integer // 3 (truncated)
def d = 10 as Double // 10.0
def l = 42 as Long // 42L
Compare with Java-style casting (which also works in Groovy):
// Java way — verbose
Integer num = (Integer) "42" // ClassCastException!
Integer num = Integer.parseInt("42") // works but verbose
// Groovy way — clean and smart
def num = "42" as Integer // just works
The key difference: Java’s (Type) cast is a hard cast that fails if types are incompatible. Groovy’s as is a coercion it actively tries to convert the value using built-in conversion logic.
This type coercion is not limited to simple data types. It can be used across collections, Map to Object coercion, Closure to Interface coercion, and more.
2. Import Aliasing
Rename imports to avoid naming conflicts or improve readability:
import java.util.Date as UtilDate
import java.sql.Date as SqlDate
def today = new UtilDate()
def sqlToday = new SqlDate(today.time)
println "Util: $today"
println "SQL: $sqlToday"
Without aliasing, you’d need fully qualified names:
// Java way — verbose
def today = new java.util.Date()
def sqlToday = new java.sql.Date(today.time)
More aliasing examples:
// Shorten long class names
import java.util.concurrent.ConcurrentHashMap as ConcMap
def cache = new ConcMap<String, String>()
// Rename for clarity
import groovy.json.JsonSlurper as JSON
def data = new JSON().parseText('{"name": "Alice"}')
// Avoid conflicts with your own classes
import com.myapp.User as AppUser
import com.thirdparty.User as ExtUser
3. List and Array Coercion
Convert between collection types effortlessly:
// List to Array
def list = [1, 2, 3, 4, 5]
def arr = list as int[] // int array
def strArr = ["a", "b"] as String[]
// Array to List
int[] numbers = [10, 20, 30]
def numList = numbers as List // ArrayList
// Set conversion (removes duplicates)
def items = [1, 2, 2, 3, 3, 3]
def unique = items as Set // [1, 2, 3]
// List to LinkedList, TreeSet, etc.
def linked = [1, 2, 3] as LinkedList
def sorted = [3, 1, 2] as TreeSet // [1, 2, 3] — auto sorted
4. Map to Object Coercion One of Groovy’s most powerful features — converting a Map directly into an object:
class Person {
String name
int age
String city
}
// Map to Object — keys match property names
def alice = [name: "Alice", age: 30, city: "Mumbai"] as Person
println alice.name // Alice
println alice.age // 30
println alice.city // Mumbai
println alice.class // class Person
This is incredibly useful for working with JSON or configuration data:
import groovy.json.JsonSlurper
def json = '{"name": "Bob", "age": 25, "city": "Delhi"}'
def map = new JsonSlurper().parseText(json)
def person = map as Person
println person.name // Bob
5. Closure to Interface Coercion
Groovy can coerce a closure into any single abstract method (SAM) interface:
// Closure as a Runnable
def task = { println "Running!" } as Runnable
new Thread(task).start()
// Closure as a Comparator
def byLength = { a, b -> a.length() <=> b.length() } as Comparator
def words = ["banana", "fig", "apple"]
println words.sort(byLength) // [fig, apple, banana]
// Closure as a Callable
import java.util.concurrent.Callable
def job = { return 42 } as Callable
println job.call() // 42
6. Map to Interface Coercion
You can implement multi-method interfaces using a Map of closures:
def listener = [
mouseClicked: { event -> println "Clicked at ${event.point}" },
mouseEntered: { event -> println "Mouse entered" },
mouseExited: { event -> println "Mouse exited" },
mousePressed: { event -> },
mouseReleased: { event -> }
] as java.awt.event.MouseListener
Each key in the map corresponds to a method name in the interface. This saves you from writing anonymous inner classes like in Java.
7. Enum Coercion
Convert Strings to Enum values:
enum Color { RED, GREEN, BLUE }
def c = "RED" as Color
println c // RED
println c.class // class Color
// Useful for parsing config/input
def userInput = "BLUE"
def selected = userInput as Color
8. Custom Coercion with asType()
You can define how your own classes respond to as by overriding asType():
class Temperature {
double celsius
Temperature(double c) { this.celsius = c }
// Custom coercion logic
Object asType(Class target) {
switch (target) {
case String:
return "${celsius}°C"
case Integer:
return celsius as Integer
case Map:
return [celsius: celsius, fahrenheit: celsius * 9/5 + 32]
default:
throw new ClassCastException("Cannot convert to $target")
}
}
}
def temp = new Temperature(36.6)
println temp as String // 36.6°C
println temp as Integer // 36
println temp as Map // [celsius:36.6, fahrenheit:97.88]
9. as with Spread Operator
Combine with Groovy’s spread operator for bulk conversions:
def strings = ["1", "2", "3", "4", "5"]
// Convert all strings to integers
def numbers = strings.collect { it as Integer }
println numbers // [1, 2, 3, 4, 5]
// Alternatively
def nums = strings*.toInteger()
println nums // [1, 2, 3, 4, 5]
in
in is a Groovy-only keyword that serves two primary purposes: iterating over collections in for-each loops and membership testing to check if a value exists within a collection, range, or any iterable. It replaces Java’s verbose : syntax in loops and adds a powerful containment operator that doesn’t exist in Java at all.
The most common use — looping through collections:
1. Iterating with for...in
// Basic list iteration
for (item in [1, 2, 3, 4, 5]) {
println item
}
// With a variable declaration
def fruits = ["Apple", "Banana", "Mango"]
for (fruit in fruits) {
println "I like $fruit"
}
Compare with Java’s approach:
// Java way
for (String fruit : fruits) {
System.out.println("I like " + fruit);
}
// Groovy way — cleaner
for (fruit in fruits) {
println "I like $fruit"
}
The difference is subtle but Groovy’s in reads more like natural English: “for each fruit in fruits.”
2. Iterating Over Different Types
in works with virtually anything iterable:
Lists
for (num in [10, 20, 30]) {
println num // 10, 20, 30
}
Ranges
// Inclusive range
for (i in 1..5) {
println i // 1, 2, 3, 4, 5
}
// Exclusive range
for (i in 1..<5) {
println i // 1, 2, 3, 4
}
// Character ranges
for (ch in 'a'..'f') {
println ch // a, b, c, d, e, f
}
// Reverse range
for (i in 5..1) {
println i // 5, 4, 3, 2, 1
}
Maps
def person = [name: "Alice", age: 30, city: "Bengaluru"]
// Iterates over Map.Entry objects
for (entry in person) {
println "${entry.key} = ${entry.value}"
}
// name = Alice
// age = 30
// city = Bengaluru
Arrays
int[] numbers = [100, 200, 300]
for (n in numbers) {
println n // 100, 200, 300
}
Strings (character by character)
for (ch in "Groovy") {
println ch // G, r, o, o, v, y
}
Enums
enum Day { MON, TUE, WED, THU, FRI, SAT, SUN }
for (day in Day.values()) {
println day
}
3. Membership Testing (the in operator)
This is where in truly shines — checking if a value exists within a collection:
// Basic membership check
println 3 in [1, 2, 3, 4, 5] // true
println 9 in [1, 2, 3, 4, 5] // false
println "Banana" in ["Apple", "Banana", "Mango"] // true
println "Grape" in ["Apple", "Banana", "Mango"] // false
Compare with Java:
// Java way — verbose
Arrays.asList(1, 2, 3, 4, 5).contains(3); // true
list.contains("Banana"); // true
// Groovy way — reads like English
3 in [1, 2, 3, 4, 5]
"Banana" in ["Apple", "Banana", "Mango"]
4. Membership with Ranges
This is incredibly powerful for boundary checks:
def age = 25
// Check if age falls within a range
println age in 18..65 // true — adult working age
println age in 0..17 // false — not a minor
// Grading system
def score = 82
switch (true) {
case score in 90..100: println "A"; break
case score in 80..89: println "B"; break
case score in 70..79: println "C"; break
case score in 60..69: println "D"; break
default: println "F"
}
// Output: B
In Java, you’d need:
if (age >= 18 && age <= 65) { ... } // verbose
5. Membership with Maps
Check if a key exists in a map:
def config = [host: "localhost", port: 8080, debug: true]
println "host" in config.keySet() // true
println "timeout" in config.keySet() // false
// Check values
println 8080 in config.values() // true
println "localhost" in config.values() // true
6. in with Strings
Important caveat: in uses the isCase() method under the hood, so for Strings it checks character membership, not substring membership. Use .contains() for substrings.
def message = "Hello Groovy World"
// This does NOT check for substrings!
println "Groovy" in message // false
// For substrings, use contains() instead
println message.contains("Groovy") // true
// Character check in a string
def word = "Groovy"
println 'G' in word.toList() // true
println 'z' in word.toList() // false
7. How in Works Under the Hood
The in operator translates to the .isCase() method call:
// These are equivalent
println 3 in [1, 2, 3]
println [1, 2, 3].isCase(3)
// For ranges
println 5 in 1..10
println (1..10).isCase(5)
This means you can make in work with your own classes by implementing isCase():
class AgeGroup {
int min
int max
AgeGroup(int min, int max) {
this.min = min
this.max = max
}
boolean isCase(int age) {
age >= min && age <= max
}
}
def teens = new AgeGroup(13, 19)
def adults = new AgeGroup(20, 64)
def age = 25
println age in teens // false
println age in adults // true
8. in with Switch Statements
Groovy’s switch is far more powerful than Java’s, and in works beautifully with it:
def classify(value) {
switch (value) {
case 1..10:
return "Small number"
case 11..100:
return "Medium number"
case Integer:
return "Large number"
case ~/[A-Z].+/:
return "Capitalized string"
case ["Apple", "Banana", "Mango"]:
return "It's a fruit"
default:
return "Unknown"
}
}
println classify(5) // Small number
println classify(42) // Medium number
println classify(500) // Large number
println classify("Hello") // Capitalized string
println classify("Apple") // It's a fruit
Behind the scenes, each case uses isCase() — the same mechanism that powers in. So case 1..10: is essentially checking if the value is in 1..10.
9. in with assert
Great for writing expressive assertions and tests:
def status = "active"
assert status in ["active", "inactive", "pending"]
def port = 8080
assert port in 1024..65535 : "Port must be between 1024 and 65535"
def role = "admin"
assert role in ["admin", "editor", "viewer"] : "Invalid role: $role"
10. in with Collection Operations
Combining in with other Groovy collection methods:
def numbers = [1, 5, 12, 18, 25, 30, 42]
def validRange = 10..30
// Filter using 'in'
def filtered = numbers.findAll { it in validRange }
println filtered // [12, 18, 25, 30]
// Partition using 'in'
def (inRange, outRange) = numbers.split { it in validRange }
println "In range: $inRange" // [12, 18, 25, 30]
println "Out of range: $outRange" // [1, 5, 42]
// Any / Every checks
def ages = [22, 35, 17, 45]
println ages.every { it in 18..65 } // false — 17 is not in range
println ages.any { it in 18..65 } // true — some are in range
11. Negation — !in
Check if something is not in a collection:
def banned = ["spam", "hack", "exploit"]
def userInput = "hello"
if (userInput !in banned) {
println "Input is safe"
}
// Also works in assertions
assert "admin" !in ["guest", "anonymous"]
in vs Java Alternatives — Comparison
| Task | Java | Groovy with in |
|---|---|---|
| Loop over list | for (T x : list) | for (x in list) |
| Range check | x >= 1 && x <= 10 | x in 1..10 |
| List membership | list.contains(x) | x in list |
| Negated check | !list.contains(x) | x !in list |
| Custom matching | Implement logic manually | Override isCase() |
trait
trait is a Groovy-only keyword that defines a special kind of construct — similar to interfaces in Java but significantly more powerful. While Java interfaces (since Java 8) can have default methods, Groovy traits can carry both state (fields) and full method implementations. Think of traits as reusable building blocks of behavior that can be mixed into any class.
1. Basic Trait Definition
A trait is defined using the trait keyword, and a class uses it with the implements keyword — just like interfaces:
trait Greetable {
String greet() {
"Hello, I'm a Greetable!"
}
}
class Person implements Greetable {
String name
}
def p = new Person(name: "Shiva")
println p.greet() // Hello, I'm a Greetable!
The Person class automatically gets the greet() method without having to implement it — the trait provides the implementation.
2. Traits with State (Fields)
Unlike Java interfaces, traits can hold fields — this is what makes them truly powerful:
trait HasAge {
int age = 0
boolean isAdult() {
age >= 18
}
String ageCategory() {
if (age < 13) return "Child"
if (age < 18) return "Teenager"
return "Adult"
}
}
class Student implements HasAge {
String name
}
def s = new Student(name: "Ravi", age: 20)
println s.isAdult() // true
println s.ageCategory() // Adult
3. Multiple Trait Implementation
This is where traits solve a major limitation of Java — the lack of multiple inheritance. A class can implement multiple traits, inheriting behavior from all of them:
trait Walkable {
String walk() { "${getName()} is walking" }
}
trait Swimmable {
String swim() { "${getName()} is swimming" }
}
trait Flyable {
String fly() { "${getName()} is flying" }
}
class Duck implements Walkable, Swimmable, Flyable {
String name
String getName() { name }
}
def d = new Duck(name: "Donald")
println d.walk() // Donald is walking
println d.swim() // Donald is swimming
println d.fly() // Donald is flying
In Java, achieving this would require either complex abstract class hierarchies or duplicating code across classes.
4. Overriding Trait Methods
A class can override methods provided by a trait, just like overriding methods from a parent class:
trait Greetable {
String greet() { "Hello from trait!" }
}
class FriendlyPerson implements Greetable {
String name
@Override
String greet() { "Hey there! I'm $name!" } // Overrides the trait method
}
def fp = new FriendlyPerson(name: "Shiva")
println fp.greet() // Hey there! I'm Shiva!
5. Conflict Resolution
When a class implements multiple traits that have methods with the same name, the last declared trait wins. You can also explicitly choose which trait’s method to use:
trait A {
String hello() { "Hello from A" }
}
trait B {
String hello() { "Hello from B" }
}
// Last trait wins by default
class MyClass implements A, B {}
def obj = new MyClass()
println obj.hello() // Hello from B (B is listed last)
// Explicitly choose which trait's method to use
class MyOtherClass implements A, B {
String hello() {
A.super.hello() // Explicitly call A's version
}
}
def obj2 = new MyOtherClass()
println obj2.hello() // Hello from A
6. Traits Extending Other Traits
Traits can extend other traits to build up behavior in layers:
trait HasName {
String name
String getName() { name }
}
trait Loggable extends HasName {
void log(String message) {
println "[${getName()}] $message"
}
}
class Service implements Loggable {
Service(String name) { this.name = name }
}
def svc = new Service("OrderService")
svc.log("Processing order #123") // [OrderService] Processing order #123
7. Abstract Methods in Traits
Traits can declare abstract methods that the implementing class must provide — just like interfaces:
trait Printable {
abstract String format() // Class MUST implement this
void print() {
println format() // Uses the class's implementation
}
}
class Invoice implements Printable {
double amount
String format() {
"Invoice amount: ₹${amount}"
}
}
def inv = new Invoice(amount: 5000)
inv.print() // Invoice amount: ₹5000
8. Runtime Trait Application
One of the most unique features — you can apply traits to objects at runtime using the as keyword (notice how as and trait work together):
trait ExtraPolite {
String politeGreet() { "Good day! How do you do?" }
}
class Person {
String name
}
def p = new Person(name: "Shiva")
// Apply trait at runtime!
def politePerson = p as ExtraPolite
println politePerson.politeGreet() // Good day! How do you do?
This means you can add behavior to existing objects without modifying their class definition — incredibly powerful for plugins, extensions, and dynamic behavior.
trait vs Java Alternatives — Comparison
| Feature | Java Interface (default methods) | Java Abstract Class | Groovy Trait |
|---|---|---|---|
| Method implementations | Yes (since Java 8) | Yes | Yes |
| Fields / State | Only constants (static final) | Yes | Yes |
| Multiple inheritance | Yes (methods only) | No | Yes (methods + state) |
| Runtime application | No | No | Yes (obj as Trait) |
| Conflict resolution | Must override | N/A | Last trait wins or use Trait.super |
Conclusion
These four keywords – def, as, in, and trait — are what set Groovy apart from Java at the language level. While they may seem small in number, they unlock powerful capabilities: dynamic typing with def, seamless type conversion and aliasing with as, expressive iteration and membership testing with in, and flexible behavior composition with trait. Understanding these keywords well will help you write more idiomatic and concise Groovy code.
