Finalize() Method in Java

Last Updated on June 23, 2023 by Mayank Dham

The Java finalize method is a method that gets invoked by the garbage collector before an object is marked for garbage collection. It provides an opportunity for subclasses to implement custom cleanup operations before the object is destroyed.
The finalize method is defined in the Object class, the superclass of all Java classes. In this article, we will delve into the details of the finalize() method, covering its syntax, usage, and recommended practices.

The syntax of the finalize() method is simple and straightforward. It has the following signature:

protected void finalize throws Throwable{}

The finalize() method takes no arguments and returns no value. It can throw a Throwable, which is the parent class of all exceptions and errors in Java. The finalize() method is defined as protected, which means that it can be accessed only by the class that defines it or by subclasses of that class.

Garbage Collector

The primary objective of the finalize() method is to carry out necessary cleanup operations before an object undergoes garbage collection. This encompasses releasing resources like file handles, network connections, and database connections. For instance, if an object holds a reference to an open file, the finalize() method can be utilized to close that file before the object is garbage collected. It is essential to note that the garbage collector does not guarantee the invocation of the finalize() method. It may choose to bypass the finalize() method if it determines that it is unnecessary. Additionally, the finalize() method may not be called only once, as the garbage collector’s behavior may vary. Consequently, any resources allocated within the finalize() method should be released within the method itself, rather than relying on its invocation.
Furthermore, it is important to consider that the finalize() method may experience significant delays before being called. The garbage collector runs periodically and may not execute precisely when an object becomes eligible for garbage collection. As a result, an object’s finalize() method may not be invoked for a considerable duration, or it may not be called at all. This can lead to performance issues if the object retains resources in high demand, such as memory or file handles.
Due to these reasons, it is generally discouraged to employ the finalize() method for resource release purposes. Instead, it is preferable to utilize try-finally or try-catch-resources constructs to ensure timely resource release. These constructs guarantee that resources are released as soon as they are no longer needed, without relying on the garbage collector’s invocation of the finalize() method.
Apart from resource release, the finalize() method in Java can also be utilized for other forms of cleanup. For instance, it can be used to halt background threads or detach event listeners. Nevertheless, it is crucial to exercise caution and refrain from utilizing the finalize() method for critical tasks, such as saving data to a database or sending messages to servers. Such tasks should be executed promptly rather than relying on the finalize() method’s invocation by the garbage collector.

How to Override finalize() Method?

The finalize() method is defined in the Object class and can be overridden by any class that extends the Object class. To override the finalize() method, you need to do the following:
Create a class that extends the Object class.
Use the @Override annotation to indicate that you are overriding a method.
Use the finalize() method’s signature, which is protected void finalize() throws Throwable.
Implement the logic of the finalize() method.
Here’s an example of how you can override the finalize() method in a class called MyClass:

import java.lang.*;
 
 class prep {
 
    protected void finalize() throws Throwable
    {
        try {
 
            System.out.println("inside prep finalize()");
        }
        catch (Throwable e) {
 
            throw e;
        }
        finally {
 
            System.out.println("Calling finalize method"
                               + " of the Object class");
 
            // Calling finalize() of Object class
            super.finalize();
        }
    }
 
    // Driver code
    public static void main(String[] args) throws Throwable
    {
 
        // Creating demo's object
        prep d = new prep();
 
        // Calling finalize of demo
        d.finalize();
    }
}

Output:

inside prep finalize()
Calling finalize method of the Object class

It’s important to note that the finalize method in java should not be used to perform critical tasks, such as saving data to a database or sending a message to a server. These types of tasks should be performed in a timely manner, rather than waiting for the garbage collector to call the finalize() method. Additionally, the garbage collector is not guaranteed to call the finalize() method, and it is not guaranteed to call it only once. Therefore, any resources that are allocated in the finalize() method should be released in the finalize() method and not rely on it being called.

Difference Between Final Finally and Finalize

In Java, "final", "finally" and "finalize" are three different keywords that have different meanings and uses.

Final Keyword in Java:

"final" is a modifier that can be applied to a variable, a method, or a class. When applied to a variable, it means that the variable’s value cannot be changed after it has been initialized. When applied to a method, it means that the method cannot be overridden by subclasses. When applied to a class, it means that the class cannot be extended by subclasses. This helps to create immutable objects and to prevent accidental overrides.

Finally Keyword in Java:

"finally" is a block of code that is used in conjunction with the "try" and "catch" statements. The "finally" block contains code that is guaranteed to be executed, regardless of whether an exception is thrown or caught. This is typically used to release resources, such as file handles or network connections, that were acquired in the "try" block.

Finalize Keyword in java:

"finalize" is a method in java that is defined in the Object class and can be overridden by subclasses. The finalize method in java is called by the garbage collector before an object is garbage collected. This method can be used to perform any necessary cleanup before the object is destroyed, such as releasing resources or detaching event listeners. However, it’s important to note that the garbage collector is not guaranteed to call the finalize method in java and it’s not guaranteed to call it only once.

In summary, "final" is a modifier that can be used to create immutable objects and to prevent accidental overrides. "finally" is a block of code that is guaranteed to be executed, regardless of whether an exception is thrown or caught. "finalize" is a method that is called by the garbage collector before an object is garbage collected and can be overridden to perform any necessary cleanup before the object is destroyed.

Conclusion:
The finalize() method in Java serves the purpose of performing cleanup operations before an object is garbage collected. It can be used to release resources, stop background threads, detach event listeners, and perform other types of cleanup. However, relying on the finalize() method for resource release is not recommended due to its unpredictable invocation and potential performance issues. It is best practice to use try-finally or try-catch-resources constructs for timely and reliable resource cleanup.

FAQs (Frequently Asked Questions) related to the finalize() method in Java:

Q1. What is the finalize() method in Java?
The finalize() method is a method defined in the Object class in Java, which is the base class for all other classes. It is invoked by the garbage collector before an object is garbage collected, providing an opportunity to perform cleanup operations.

Q2. What is the purpose of the finalize() method?
The primary purpose of the finalize() method is to perform any necessary cleanup before an object is destroyed. This can include releasing resources such as file handles, network connections, and database connections.

Q3. Is the finalize() method guaranteed to be called by the garbage collector?
No, the garbage collector is not guaranteed to call the finalize() method. It may choose to skip the finalize() method if it determines that it is unnecessary or if it hasn’t run for a long time.

Q4. Can the finalize() method be called multiple times for the same object?
Yes, the finalize() method can be called multiple times for the same object if it survives garbage collection and becomes eligible for garbage collection again.

Q5. Can the finalize() method cause delays in object destruction?
Yes, the finalize() method can cause delays in object destruction as it relies on the garbage collector’s periodic execution. The method may not be called immediately when an object becomes eligible for garbage collection, leading to potential performance issues if the object holds resources in high demand.

Q6. What are the alternatives to using the finalize() method for resource cleanup?
It is recommended to use try-finally or try-catch-resources constructs for resource cleanup. These constructs ensure timely and reliable resource release without relying on the finalize() method.

Q7. Can the finalize() method be used for critical tasks such as saving data or sending messages?
No, the finalize() method should not be used for critical tasks that require prompt execution, such as saving data to a database or sending messages to servers. These tasks should be performed in a timely manner rather than waiting for the finalize() method’s invocation by the garbage collector.