Finalize() Method in Java

The finalize method in Java is a method that is called by the garbage collector before an object is a garbage collected. This method can be overridden by subclasses to perform any necessary cleanup before the object is destroyed.
The finalize method in java is defined in the Object class, which is the parent class of all Java classes. In this article, we will discuss the finalize() method in detail, including its syntax, usage, and best 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 main purpose of the finalize() method is to perform any necessary cleanup before an object is garbage collected. This can include releasing resources such as file handles, network connections, and database connections. For example, if an object holds a reference to an open file, the finalize() method can close that file before the object is garbage collected.
It’s important to note that the garbage collector is not guaranteed to call the finalize() method. The garbage collector may choose to skip the finalize() method if it determines that it is not necessary. Additionally, the garbage collector is not guaranteed to call the finalize() method 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.
Another thing to keep in mind is that the finalize() method can take a long time to be called. The garbage collector runs periodically and may not run at the exact time when an object becomes eligible for garbage collection. This means that an object’s finalize() method may not be called for a long time, if at all. This can cause performance issues if the object holds resources that are in high demand, such as memory or file handles.
For these reasons, it’s generally not a good idea to use the finalize() method for releasing resources. Instead, it’s best to use try-finally or try-catch-resources constructions to ensure that resources are released in a timely manner. These constructions ensure that resources are released as soon as they are no longer needed, rather than waiting for the garbage collector to call the finalize() method.
In addition to releasing resources, the finalize method in java can also be used to perform other types of cleanup. For example, it can be used to stop background threads or to detach event listeners. However, it’s important to keep in mind that the finalize() method 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.

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 is a method that is called by the garbage collector before an object is a garbage collected. It can be overridden by subclasses to perform any necessary cleanup before the object is destroyed. However, it’s important to keep in mind that the garbage collector is not guaranteed to call the finalize method in java and it’s not guaranteed to call it.