Finally Block in Kotlin - Scaler Topics

Overview

A finally block in Kotlin is used to define code that should be executed regardless of whether an exception is thrown or not within a try block. This ensures that cleanup or resource release operations occur reliably. The finally block in Kotlin runs after the try block's execution, irrespective of whether an exception was caught or not, making it useful for tasks like closing files, releasing locks, or cleaning up resources.

Introduction

The finally block in Kotlin is a fundamental part of error handling within a try-catch-finally structure. It ensures that a certain block of code is executed no matter what, whether an exception is thrown or not. The finally block in Kotlin ensures that critical cleanup operations are carried out, even if an exception occurs. It's used to guarantee the execution of specific code paths, enhancing the reliability of your programs in situations involving exceptions and resource management.

Understanding finally Blocks

In programming, especially when dealing with potential errors or exceptions, it's crucial to maintain the integrity of your code and resources. This is where the finally block comes into play.

Imagine you have a piece of code that might throw an exception, and you want to ensure that certain cleanup operations or resource releases take place regardless of whether an exception occurs. This is where the finally block becomes valuable.

Here's how it works:

try Block:

You place the code that might throw an exception inside the try block.
catch Block (Optional):

If an exception occurs within the try block, the program will jump to the corresponding catch block that matches the exception type. You can have multiple catch blocks for different exception types.
finally Block:

This block follows the try and catch blocks. It contains code that will always be executed, whether an exception was thrown or not. This makes it suitable for tasks like releasing resources (files, network connections) or performing cleanup operations.

Syntax and Example

The syntax and an example of using the finally block in Kotlin:

Let's see an example of the try, catch, and finally blocks in Kotlin for exception handling.

Output:

The try block contains code that attempts to access an element in an array at an index that doesn't exist (array[10]). This will result in an IndexOutOfBoundsException.
Since an exception is thrown, the program moves to the catch block, which handles exceptions of type IndexOutOfBoundsException
The catch block prints a message indicating that the exception has been caught, along with the exception itself.
The finally block is executed, regardless of whether an exception occurred or not. In this example, it contains a message indicating that cleanup or finalization code could be placed here.

Let's see an other important example of finally block on connecting database:

When you run this code, if the connection is successful, the output will be:

If there's an error connecting to the database:

In this example, the try block attempts to establish a connection to a hypothetical MySQL database using the JDBC driver. Inside the try block, you can perform various database operations. If a SQLException occurs (for example, if the connection fails or an SQL error occurs), the appropriate catch block will handle the exception and print an error message. The finally block is used to ensure that the database connection is properly closed, regardless of whether an exception occurred or not.

finally vs catch

The try, catch, and finally blocks are used in Kotlin to handle exceptions. The try block is used to specify a block of code that may throw an exception. The catch block is used to handle the exception if it is thrown. The finally block is used to execute the code after the try and catch blocks have been executed, regardless of whether an exception was thrown.

The main difference between finally and catch is that finally is always executed, while catch is only executed if an exception is thrown. This means that the finally block can be used to perform cleanup operations, such as closing files or releasing resources, even if an exception is thrown. Differences between the finally and catch blocks in Kotlin:

Aspect	finally Block	catch Block
Purpose	Contains code that will always be executed, regardless of whether an exception occurred or not.	Contains code to handle exceptions that occur within the associated try block.
Execution Order	Executes after the try block and any matching catch blocks (if present).	Executes only if an exception of the specified type is thrown within the try block.
Exception Propagation	Exceptions are not caught by the finally block. They will continue to propagate if not caught within the try block.	Exceptions are caught by the catch block and can be handled or rethrown from within the catch block.
Usage	Typically used for cleanup or resource release tasks that should be performed regardless of exceptions.	Used to handle specific exceptions by providing appropriate handling code.
Multiple Blocks	A single try block can be associated with a single finally block.	Multiple catch blocks can be chained to handle different types of exceptions.

Conclusion

The finally block in kotlin is an essential component of exception handling in Kotlin, offering a way to execute code regardless of exceptions.
It follows the try-catch construct and executes after the try block, irrespective of whether exceptions are caught or not.
The try, catch, and finally, blocks are used in Kotlin to handle exceptions.
The finally block in Kotlin doesn't catch exceptions itself but is a powerful tool to address scenarios needing deterministic execution.
The main difference between finally and catch is that finally is always executed, while the catch is only executed if an exception is thrown.
Common use cases involve closing files, releasing resources, ensuring proper shutdown, and maintaining data integrity.
When combined with try-catch, the finally block enhances exception management and resource control.