final finally and finalize in Java

In Java, final, finally, and finalize are distinct keywords used in different contexts. Let’s explore the differences between them:

1. final:

• final is a keyword used to declare a constant, mark a method as not overrideable, or indicate that a class cannot be subclassed (can’t inherited).
• When applied to a variable, it means the variable’s value cannot be changed once assigned.
• When applied to a method, it means the method cannot be overridden by subclasses.
• When applied to a class, it means the class cannot be subclassed (can’t inherited).

Example:

final int constantValue = 10;

final class FinalClass {
    // Code for the final class
}

class Example {
    final void finalMethod() {
        // Code for the final method
    }
}

2. finally:

• finally is used in a try-catch-finally block to define a block of code that will be executed whether an exception is thrown or not.
• It is typically used for cleanup operations or releasing resources, ensuring that certain code is executed regardless of whether an exception occurs.

Example:

try {
    // Code that may throw an exception
} catch (Exception e) {
    // Handle the exception
} finally {
    // Code in this block will be executed regardless of whether an exception occurred or not
    // This is useful for cleanup operations or resource release
}

3. finalize:

• finalize is a method in the Object class that can be overridden by a class to perform cleanup operations before an object is garbage-collected.
• It is called by the garbage collector before reclaiming the memory occupied by the object.
• However, it’s important to note that using finalize for resource cleanup is discouraged in modern Java development due to its unpredictable timing and other issues.

Example:

class ResourceHolder {
    // Some resource or state to be cleaned up
    private String resource;

    public ResourceHolder(String resource) {
        this.resource = resource;
    }

    @Override
    protected void finalize() throws Throwable {
        try {
            // Cleanup operations, e.g., closing a file
            System.out.println("Finalizing: " + resource);
        } finally {
            // Call the finalize method of the superclass
            super.finalize();
        }
    }
}

In summary:

• final: Used for constants, methods, or classes to indicate immutability or prevent further modification or extension.
• finally: Used in exception handling to define a block of code that is always executed, regardless of whether an exception is thrown or not.
• finalize: A method in the Object class that can be overridden for cleanup operations before an object is garbage-collected; however, its usage is discouraged in modern Java development.

Here’s a tabular representation of the differences between final, finally, and finalize in Java:

This table summarizes the key differences in usage, purpose, and characteristics of final, finally, and finalize in Java.