Groovy - Exception Handling

11. Exception Handling

Exception handling is a crucial aspect of any programming language, including Groovy. Exceptions are runtime errors that can occur during program execution. Groovy provides a robust mechanism for handling exceptions to ensure that your programs can gracefully recover from errors.

Types of Exceptions in Groovy:

Groovy, like Java, has a hierarchy of exception classes. The base class for all exceptions is 'java.lang.Exception'. Some common exception types in Groovy include:

1. 'java.lang.Exception': The base class for all exceptions.
2. 'java.lang.RuntimeException': The base class for runtime exceptions.
3. Custom Exception Classes: You can create your own exception classes by extending 'java.lang.Exception' or its subclasses.

The'try-catch'Block:

In Groovy, you can handle exceptions using a 'try-catch' block. This block allows you to specify code that might throw an exception and then provide one or more 'catch' blocks to handle those exceptions.

try {
    // Code that might throw an exception
} catch (ExceptionType1 e1) {
    // Handle ExceptionType1
} catch (ExceptionType2 e2) {
    // Handle ExceptionType2
} finally {
    // Optional: Code that runs regardless of whether an exception occurred or not
}

try {
    def result = 10 / 0 // This will throw an ArithmeticException
} catch (ArithmeticException e) {
    println("An arithmetic error occurred: ${e.message}")
} finally {
    println("Cleanup code: This always runs")
}

In this example, we catch an 'ArithmeticException' that occurs when dividing by zero, and we  also have a 'finally' block that executes regardless of whether an exception occurred or not.

The'throw'Statement:

You can manually throw exceptions using the 'throw' statement. This is useful when you want to create custom exceptions or handle specific error cases.

def age = -5

try {
    if (age < 0) {
        throw new IllegalArgumentException("Age cannot be negative")
    }
    println("Age is valid: $age")
} catch (IllegalArgumentException e) {
    println("Invalid age: ${e.message}")
}

In this example, we manually throw an 'IllegalArgumentException' if the age is negative.

Handling Multiple Exceptions:

You can handle multiple exceptions by adding multiple 'catch' blocks for different exception types.

try {
    // Code that might throw exceptions
} catch (IOException e) {
    // Handle IOException
} catch (IllegalArgumentException e) {
    // Handle IllegalArgumentException
}

try {
    // Code that might throw an exception
} catch (ExceptionType) {
    // Handle the exception without accessing the exception object
}

class MyCustomException extends Exception {
    MyCustomException(String message) {
        super(message)
    }
}

try {
    throw new MyCustomException("This is a custom exception")
} catch (MyCustomException e) {
    println("Caught custom exception: ${e.message}")
}