Groovy - Functions and Methods

8. Functions and Methods

Functions and methods in Groovy are essential building blocks that encapsulate blocks of code for reuse. They enhance code modularity, maintainability, and readability by breaking down complex tasks into smaller, manageable parts.

Functions:

A function in Groovy is a self-contained, reusable block of code that performs a specific task. Functions are not tied to objects or classes and can be defined independently.

Defining Functions:

You can define a function in Groovy using the 'def' keyword, followed by the function name, parameters (if any), and a code block enclosed in curly braces '{}'.

def functionName(param1, param2, ...) {
    // Function code here
    return result // Optional return statement
}

def greet(name) {
    return "Hello, ${name}!"
}

def message = greet("Alice")
println(message) // Output: Hello, Alice!

In this example, the 'greet' function takes a 'name' parameter and returns a greeting message.

Parameters:

Functions can accept zero or more parameters, which act as inputs to the function. Parameters are variables that hold values passed when the function is called.

def add(a, b) {
    return a + b
}

def result = add(5, 3)
println("Sum: ${result}") // Output: Sum: 8

def isEven(number) {
    if (number % 2 == 0) {
        return true
    } else {
        return false
    }
}

def num = 6
def isNumEven = isEven(num)
println("Is ${num} even? ${isNumEven}") // Output: Is 6 even? true

In this example, the 'isEven' function checks if a number is even and returns 'true' or 'false' accordingly.

Default Parameters:

You can specify default values for function parameters. If no argument is passed for a parameter with a default value, the default value is used.

def greet(name = "Guest") {
    return "Hello, ${name}!"
}

def message1 = greet() // No argument provided
def message2 = greet("Alice") // Argument provided

println(message1) // Output: Hello, Guest!
println(message2) // Output: Hello, Alice!

def sumAll(...numbers) {
    def total = 0
    for (num in numbers) {
        total += num
    }
    return total
}

def result = sumAll(1, 2, 3, 4, 5)
println("Sum: ${result}") // Output: Sum: 15

def applyOperation(operation, a, b) {
    return operation(a, b)
}

def add = { x, y -> x + y }
def multiply = { x, y -> x * y }

def result1 = applyOperation(add, 3, 4)
def result2 = applyOperation(multiply, 3, 4)

println("Addition: ${result1}") // Output: Addition: 7
println("Multiplication: ${result2}") // Output: Multiplication: 12

In this example, the 'applyOperation' function accepts a closure 'operation' and applies it to 'a' and 'b'.

Scope:

Functions have their own scope, which means variables defined inside a function are local to that function and do not affect variables outside of it.

def x = 10

def myFunction() {
    def x = 20
    println("Inside function: x = ${x}")
}

myFunction()
println("Outside function: x = ${x}")

// Output:
// Inside function: x = 20
// Outside function: x = 10

In this example, the 'x' variable inside the 'myFunction' function is local to the function and does not affect the 'x' variable outside of it.

Function Overloading:

Groovy supports function overloading, which means you can define multiple functions with the same name but different parameter lists.

def greet(name) {
    return "Hello, ${name}!"
}

def greet(firstName, lastName) {
    return "Hello, ${firstName} ${lastName}!"
}

def message1 = greet("Alice")
def message2 = greet("Bob", "Smith")

println(message1) // Output: Hello, Alice!
println(message2) // Output: Hello, Bob Smith!

In this example, we defined two 'greet' functions with different parameter lists.

Methods:

Methods in Groovy are functions that are associated with objects or classes. They encapsulate behavior and allow you to perform operations on objects or manipulate data. Methods are defined within classes.

Defining Methods:

Methods in Groovy are defined within classes using the 'def' keyword, followed by the method name, parameters (if any), and a code block enclosed in curly braces '{}'.

class ClassName {
    def methodName(param1, param2, ...) {
        // Method code here
        return result // Optional return statement
    }
}

class Calculator {
    def add(a, b) {
        return a + b
    }
}

In this example, we define a 'Calculator' class with a method 'add' that takes two parameters, 'a' and 'b', and returns their sum.

Calling Methods:

To call a method, you need to create an instance of the class (an object) and then use the object's name followed by a dot '.' and the method name.

Example:

def calculator = new Calculator()
def result = calculator.add(5, 3)
println("Sum: ${result}") // Output: Sum: 8

In this example, we create an instance of the 'Calculator' class named 'Calculator'and call its 'add' method to calculate the sum of '5' and '3'.

Parameters:

Methods can accept one or more parameters, which are placeholders for values that the method needs to work with.

Example:

class Rectangle {
    def calculateArea(width, height) {
        return width * height
    }
}

def rectangle = new Rectangle()
def area = rectangle.calculateArea(4, 6)
println("Area: ${area}") // Output: Area: 24

In this example, the 'Rectangle' class has a method 'calculateArea' that takes two parameters, 'width' and 'height', and calculates the area of a rectangle.

Return Values:

Methods can return values using the 'return' statement. If no 'return'statement is used, the method returns 'null' by default.

class MathOperations {
    def square(number) {
        return number * number
    }
}

def math = new MathOperations()
def squaredValue = math.square(5)
println("Squared Value: ${squaredValue}") // Output: Squared Value: 25

In this example, the 'MathOperations' class defines a 'square' method that returns the square of a number.

Access Control:

Methods in Groovy can have access modifiers like 'public', 'private', or 'protected', which control their visibility and accessibility.

class BankAccount {
    private def balance = 0

    public void deposit(amount) {
        balance += amount
    }

    public int getBalance() {
        return balance
    }
}

def account = new BankAccount()
account.deposit(100)
def currentBalance = account.getBalance()
println("Current Balance: ${currentBalance}") // Output: Current Balance: 100

class OverloadedMethods {
    def calculate(a, b) {
        return a + b
    }

    def calculate(a, b, c) {
        return a + b + c
    }
}

def operations = new OverloadedMethods()
def result1 = operations.calculate(1, 2)
def result2 = operations.calculate(1, 2, 3)

println("Result 1: ${result1}") // Output: Result 1: 3
println("Result 2: ${result2}") // Output: Result 2: 6

In this example, we defined two 'calculate' methods with different parameter lists.

Conclusion:

Functions and methods are powerful tools in Groovy that allow you to create reusable and modular code. Understanding how to define, call, and work with functions and methods is essential for effective Groovy programming, as it helps you write clean, organized, and maintainable code.