Dynamic Language Characteristics

Groovy operates on the Java Virtual Machine as a dynamic programming language that maintains close syntactic resemblance to Java. This design enables seamless interoperability with existing Java codebases while introducing enhanced flexibility through dynamic typing features including closures and domain-specific language capabilities.

The syntactic compatibility with Java allows developers unfamiliar with Groovy to utilize Java-style syntax when writing Groovy code, providing a smooth learning curve for Java developers transitioning to Groovy.

Type Inference with def Keyword

The def keyword serves as Groovy's flexible declaration mechanism for variables, methods, and properties. It enables type inference where the compiler automatically determines the appropriate type based on assigned values, eliminating the need for explicit type declarations.

As a dynamically typed language, Groovy exhibits characteristics of both strong and weak typing depending on implemantation choices. Explicit type declarations provide compile-time safety similar to strong typing, while implicit typing offers runtime flexibility akin to weak typing.

Variable Declarations

Variables declared with def undergo automatic type determination at runtime:

def counter = 42 // Inferred as Integer
def message = "Greetings" // Inferred as String

Dynamic Typing Flexibility

Variables defined using def can change their referenced object types during execution since the variable itself lacks a fixed type constraint:

def flag = false // Initially Boolean
deflag = "Modified" // Now references String

Method Definitions

The def keyword also facilitates method creation where return types are either inferred by the compiler or implicitly void:

def calculate(x, y) {
    return x * y
}

Property Declarations

Class properties can utilize def for dynamic type inference, automatically generating corresponding getter and seter methods.

String Handling

Groovy extends Java's string capabilities by supporting single quotes alongside double quotes:

task demonstrateStrings {
    String greeting = "Welcome"
    var target = "Developer"
    def punctuation = "!"
    println("${greeting} ${target}" + punctuation)
}

Collections: Lists

List structures use square bracket notation for initialization and offer convenient iteration patterns:

task demonstrateLists {
    def numbers = [10, 20, 30, 40, 50]
    println numbers[0]

    // Iteration approach one
    for (int item : numbers) {
        println(item)
    }
    
    // Iteration approach two
    for(int index : 0..4){
        println(numbers[index])
    }
}

Collections: Maps

Map structures follow key-value pair syntax and provide straightforward traversal mechanisms:

task demonstrateMaps() {
    def person = ["identifier": 'john', "years": 25]
    println person["identifier"]
    
    person.each {
        println it
        println "${it.key}:${it.value}"
    }
}

Function Behavior

Groovy automatically returns the last non-empty expression in function bodies without requiring explicit return statements:

def multiplyValues(int first, int second) {
    first * second
}

Object-Oriented Features

Class definitions closely mirror Java conventions:

class Person {
    private String fullName
    private int birthYear

    private String getFullName() {
        return fullName
    }

    private int getBirthYear() {
        return birthYear
    }

    private void setFullName(String name) {
        this.fullName = name
    }

    private void setBirthYear(int year) {
        this.birthYear = year
    }

    @Override
    String toString() {
        return "Person{fullName='${fullName}', birthYear=${birthYear}}"
    }
}

task demonstrateClass() {
    Person individual = new Person()
    individual.fullName = "Sample User"
    individual.birthYear = 1990
    println(individual)
    
    individual.setFullName("Updated Name")
    individual.setBirthYear(1991)
    println(individual)
}

Closures

Closures represent self-contained, anonymous code blocks capable of accepting parameters and returning values, functioning similarly to anonymous classes or inteerfaces.

Closure Syntax

Closure parameters can range from zero to multiple entries:

{ [parameters ->] 
	// Implementation code
}

Groovy's syntactic sugar allows omitting parentheses around closure arguments. Curly braces {} define closure scope exclusively.

Basic Closure Example

def executionBlock = {
    println("Process initiating...")
    println("Process completing...")
}

// Invocation methods
executionBlock() 
executionBlock.call()

Practical Application: Property File Processing

def extractServerAddress(String environment) {
    def address

    Properties config = new Properties()
    def configFile = file("src/main/filters/${environment}/settings.properties")
    
    if (configFile.canRead()) {
        config.load(new FileInputStream(configFile))
        if (config != null) {
            address = config["ENDPOINT"]
        }
    }

    address
}