What is the difference between final, finally, and finalize?

Table of Contents

• Introduction
• Understanding final, finally, and finalize in Java
  • 1. The **final** Keyword
    • Usage of final:
    • Example: Using final in Java
  • 2. The **finally** Keyword
    • Usage of finally:
    • Example: Using finally in Java
  • 3. The **finalize** Method
    • Usage of finalize:
    • Example: Using finalize in Java
• Practical Differences and Usage
  • Scenario 1: Declaring a Constant
  • Scenario 2: Exception Handling and Cleanup
  • Scenario 3: Garbage Collection Cleanup (Not Recommended)
• Conclusion

Introduction

In Java, the terms final, finally, and finalize might seem similar, but they have distinct purposes and usage. These keywords and concepts are critical for writing efficient, error-free Java programs. In this guide, we'll explain the differences between them and provide practical examples for each.

Understanding final, finally, and finalize in Java

While these terms look similar, they are used for very different purposes in Java. Here's an in-depth look at each one:

1. The **final** Keyword

The final keyword is used in Java to define constants, prevent method overriding, and prevent inheritance. It can be applied to variables, methods, and classes.

Usage of final:

• Final Variables: Declaring a variable as final ensures that it cannot be reassigned once it is initialized. This is often used to create constants.
• Final Methods: A method declared as final cannot be overridden by subclasses.
• Final Classes: A class declared as final cannot be extended by other classes.

Example: Using final in Java

• final ensures that PI and maxCount cannot be modified once assigned.
• The displayMessage method cannot be overridden by subclasses.

2. The **finally** Keyword

The finally keyword is used in Java in the context of exception handling. It defines a block of code that will always execute after a try block, regardless of whether an exception is thrown or not. It is typically used to release resources like closing file streams or database connections.

Usage of finally:

• In Exception Handling: The finally block is executed after the try block and any associated catch blocks, ensuring that certain cleanup code runs regardless of whether an exception occurred.

Example: Using finally in Java

• Regardless of the exception thrown in the try block, the finally block always runs to clean up or finalize any actions (like closing resources).

• Output:

3. The **finalize** Method

The finalize method is part of the Object class and is called by the garbage collector before an object is destroyed. It provides an opportunity for an object to clean up resources (like closing file handles or network connections) before being removed from memory. However, it is not recommended to rely on finalize for resource management, as its timing is unpredictable.

Usage of finalize:

• The finalize method is automatically called by the garbage collector just before the object is reclaimed. This is a way to perform cleanup actions (e.g., releasing resources like memory, files, or network connections).

Example: Using finalize in Java

• The finalize method is invoked when the garbage collector is about to reclaim the memory used by the obj object.
• Note: It’s generally not recommended to use finalize for resource management because you cannot predict when it will be called. Instead, use try-with-resources or explicit resource cleanup methods like close().

Practical Differences and Usage

Scenario 1: Declaring a Constant

To create a constant, use the final keyword:

Scenario 2: Exception Handling and Cleanup

To ensure cleanup occurs even after an exception, use the finally block:

Scenario 3: Garbage Collection Cleanup (Not Recommended)

You might use finalize to clean up resources before an object is destroyed (though it’s better to use other methods like try-with-resources):

Conclusion

While final, finally, and finalize may look similar, they serve distinct purposes in Java:

• **final** is used to declare constants, prevent method overriding, and prevent class inheritance.
• **finally** ensures that certain code (like cleanup) always runs after a try-catch block, regardless of exceptions.
• **finalize** is used by the garbage collector to clean up resources before an object is garbage collected, though it's less commonly used in modern Java programming.

Understanding the differences and appropriate use cases for these keywords is essential for writing efficient and reliable Java code.