Java Destructor

In Java, when we create an object of the class it occupies some space in the memory (heap). If we do not delete these objects, it remains in the memory and occupies unnecessary space that is not upright from the aspect of programming. To resolve this problem, we use the destructor. In this section, we will discuss the alternate option to the destructor in Java. Also, we will also learn how to use the finalize() method as a destructor.

The destructor is the opposite of the constructor. The constructor is used to initialize objects while the destructor is used to delete or destroy the object that releases the resource occupied by the object.

Remember that there is no concept of destructor in Java. In place of the destructor, Java provides the garbage collector that works the same as the destructor. The garbage collector is a program (thread) that runs on the JVM. It automatically deletes the unused objects (objects that are no longer used) and free-up the memory. The programmer has no need to manage memory, manually. It can be error-prone, vulnerable, and may lead to a memory leak.

In modern Java programming, emphasis is placed on proper resource management through the use of try-with-resources for handling IO resources and the implementation of AutoCloseable for custom resource types. These mechanisms ensure that resources are released in a timely and deterministic manner, mitigating the risk of memory leaks and resource exhaustion.

Furthermore, in Java, memory management is typically handled by the JVM's garbage collector that runs as a separate thread and automatically reclaims memory occupied by unreachable objects. This automated memory management alleviates the need for manual memory management, reducing the potential for memory leaks and simplifying the development process.

By ensuring that resources are released in a predictable and timely way, these strategies reduce the possibility of memory leaks and resource depletion. Moreover, the JVM's garbage collector, which operates as a separate thread and automatically recovers memory used by inaccessible objects, normally handles memory management in Java. The development process is made simpler and there is less chance of memory leaks thanks to this automatic memory management, which replaces the requirement for human memory management.

What is the destructor in Java?

It is a special method that automatically gets called when an object is no longer used. When an object completes its life-cycle the garbage collector deletes that object and deallocates or releases the memory occupied by the object.

It is also known as finalizers that are non-deterministic. In Java, the allocation and deallocation of objects handled by the garbage collector. The invocation of finalizers is not guaranteed because it invokes implicitly.

Advantages of Destructor

1. Automatic Resource Cleanup: Destructors automatically release resources occupied by an object when it goes out of scope or is explicitly deleted. This ensures that resources such as memory, file handles, or network connections are properly released, preventing memory leaks and resource exhaustion.
2. Automatic Invocation: Unlike regular methods, destructors are automatically invoked when an object is destroyed or goes out of scope without requiring explicit calls from the programmer. It helps ensure that cleanup actions are consistently performed, even in complex or error-prone code paths, improving code reliability and maintainability.
3. Ease of Use: Destructors do not accept any parameters and cannot be overloaded, simplifying their usage and avoiding potential confusion or misuse. This straightforward interface makes it easier for developers to implement cleanup logic without needing to worry about method signatures or overload resolution.
4. Automatic Cleanup at Program Termination: Destructors are invoked automatically when an object's lifetime ends, which typically occurs at the end of program execution. It ensures that resources are released even in scenarios where exceptions occur, or program flow diverges, helping maintain the system stability and preventing resource leaks over the long term.

How does destructor work?

When the object is created it occupies the space in the heap. These objects are used by the threads. If the objects are no longer is used by the thread it becomes eligible for the garbage collection. The memory occupied by that object is now available for new objects that are being created. It is noted that when the garbage collector destroys the object, the JRE calls the finalize() method to close the connections such as database and network connection.

From the above, we can conclude that using the destructor and garbage collector is the level of developer's interference to memory management. It is the main difference between the two. The destructor notifies exactly when the object will be destroyed. While in Java the garbage collector does the same work automatically. These two approaches to memory management have positive and negative effects. But the main issue is that sometimes the developer needs immediate access to memory management.

Java finalize() Method

It is difficult for the programmer to forcefully execute the garbage collector to destroy the object. But Java provides an alternative way to do the same. The Java Object class provides the finalize() method that works the same as the destructor. The syntax of the finalize() method is as follows:

Syntax:

Purpose

The primary purpose of the finalize() method is to ensure proper cleanup of external resources like file handles, database connections, or network sockets before the object is destroyed. By overriding this method, developers can implement custom cleanup logic tailored to the specific needs of their application.

Limitations

There are several limitations and considerations to keep in mind when using the finalize() method:

• It is a protected method of the Object class, so it can only be accessed within the class or its subclasses.
• The finalize() method can only be called once for each object. After it's been invoked by the garbage collector, subsequent calls to finalize() will have no effect.
• Exceptions thrown by the finalize() method are ignored by the JVM, except for unchecked exceptions. It means that any exceptions thrown during finalization will not terminate the program but may affect its behavior.

It is not a destructor but it provides extra security. It ensures the use of external resources like closing the file, etc. before shutting down the program. We can call it by using the method itself or invoking the method System.runFinalizersOnExit(true).

• It is a protected method of the Object class that is defined in the java.lang package.
• It can be called only once.
• We need to call the finalize() method explicitly if we want to override the method.
• The gc() is a method of JVM executed by the Garbage Collector. It invokes when the heap memory is full and requires more memory for new arriving objects.
• Except for the unchecked exceptions, the JVM ignores all the exceptions that occur by the finalize() method.

Example of Destructor

DestructorExample.java

Output:

Object is destroyed by the Garbage Collector Inside the main() method Object is destroyed by the Garbage Collector 

Explanation

The supplied code snippet shows how to use the finalize () method in Java and its syntax. The protected access modifier is used in the code block to define the finalize () method, which limits access to the class and its subclasses. The throws Throwable clause in the method signature indicates that it may throw any kind of exception.The finalise() method is where cleanup measures should be carried out, according to the comments.

Before the object is garbage collected, these activities usually entail relinquishing resources, such as shutting down files, database connections, or network ports. The code sample does not, however, contain the actual cleanup logic, which must be written in accordance with the application's particular requirements.

The code points out that although Java's finalize () method offers an alternate technique for resource cleanup, it is not a true destructor. By making ensuring that external resources are used appropriately before the programme is terminated, it improves security and dependability.

The code snippet also draws attention to a few significant drawbacks and restrictions of the finalize () function, including its protected access level, the fact that it may only be used once per object, and how exceptions raised during finalization are handled.