Skip to content

Finally block in Java

Imagine this: you're writing a piece of code, and everything seems to be going smoothly. But then, disaster strikes—an unexpected exception occurs, throwing your carefully crafted program off balance. This is where the finally block steps in, like a loyal guardian, to ensure that no matter what happens, certain actions are always taken.

A block of statements that are guaranteed to be executed, whether an exception occurs or not. It's like having a backup plan in place Example:

public class FinallyBlockExample {
    public static void main(String[] args) {
        try {
            // Perform some risky operation
            int result = divide(10, 0);
            System.out.println("Result: " + result); // This line won't be reached
        } catch (ArithmeticException e) {
            System.out.println("Error: Cannot divide by zero!");
        } finally {
            System.out.println("Inside finally block - Cleaning up resources...");

    public static int divide(int num1, int num2) {
        return num1 / num2;

In this example, we attempt to divide a number by zero, which results in an ArithmeticException. But fear not! Even though an exception occurs, the finally block still gets executed, allowing us to perform cleanup tasks or release resources, ensuring that our program remains in a stable state.

But why do we need the finally block, you ask? Well, imagine you're working on a critical piece of software—a banking application, for instance. Without the finally block, an uncaught exception could leave vital resources hanging, leading to potential data corruption or security vulnerabilities. The finally block acts as a safety mechanism, ensuring that no loose ends are left behind.

Waytojava is designed to make learning easier. We simplify examples for better understanding. We regularly check tutorials, references, and examples to correct errors, but it's important to remember that humans can make mistakes.