Java Destructor

How does Java Destructor work?

When an item is formed, space in a heap is taken up by it. The threads make use of these items. The items become eligible for trash collection if the thread is no longer using them. That object's memory space is now free to be used by newly generated objects. It should be noted that the JRE runs the finalise() method to shut off connections to databases and networks when the garbage collector destroys an object. The use of the destructor and garbage collector, as seen above, is the extent of the developer's interaction with memory management. The primary distinction between the two is this. The object will be destroyed at the precise time specified by the destructor. However, the garbage collector performs the identical task automatically in Java. Both of these memory management strategies have advantages and disadvantages. The main issue, though, is that the developer occasionally need rapid access to memory management.

Advantages of Destructor

If we talk about the advantages of destructors in general, it offers one last opportunity to free up resources that are not in use to liberate RAM that is being taken by unused objects. Examples include deleting dynamic objects, shutting system handles, and using files. It also comes with a decent picture to eliminate those unnecessary items, lowering the possibility of memory leak. The compiler automatically creates a destructor for a programme if the user does not define one on their own. 

Now let us see the advantages of destructor in java specifically. 

• The destructor eliminates the value that the function produced to free up memory space in the heap.
   
• The program's destructor is always invoked after it is finished.
   
• Destructor doesn't accept any arguments and is never overloaded.
   
• The compiler provides a function for us; we don't need to define one.

Disadvantages of Destructor

Disadvantages of using destructors include:

• Unpredictable Timing: Destructors may not execute immediately, leading to uncertainty about when resources are actually released.
• Complexity in Exception Handling: Destructors should not throw exceptions; handling errors during destruction can be complicated.
• Inefficiency with Managed Resources: Over-reliance on destructors for resource management can lead to inefficiencies, especially in garbage-collected environments.
• Inheritance Complications: Properly managing destructors in inheritance hierarchies can be challenging, requiring careful design to avoid resource leaks or undefined behavior.
• Potential for Resource Leaks: If not correctly implemented, destructors can lead to resource leaks, especially in cases of early exits from functions or blocks.
• Difficulty in Debugging: Issues arising within destructors can be harder to trace and debug due to their automatic invocation by the runtime system.

Java Finalize() Method

You can use Object#finalize in Java as a workaround for destructors. Finalize is a unique method called automatically when an object is no longer used. Although not a destructor, it works very similarly to a java destructor. Finalize is a protected method of the Object class, defined in java.lang package.

To use Finalize like a destructor, we need to call it explicitly to override it; otherwise, it is called entirely at the discretion of the garbage collector. We can only call it once. JVM ignores all the exceptions by the finalize() method except the unchecked exception. Apart from calling it by using the method itself, we can also invoke the method System.runFinalizersOnExit(true).

Syntax

Class Object
{
	protected void finalize()
	{
	//resources to close
	}
}

Implementation

Finally, we can see a basic implementation of a Java Destructor using the finalize method.

Code

• Java

Java

public void finalize() throws Throwable{
	System.out.println("Object is destroyed by the Garbage Collector");
}

public static void main(String[] args) {
  
	A test = new A();
	test = null;
	System.gc();
}

You can also try this code with Online Java Compiler

Run Code

Output

Example of Destructor

Implementation

• Java

Java

class Shoes {

   /* instance variables of shoes class*/
   private String Brand;
   private int Size;

   /* constructor */
   public Shoes(String Brand, int Size) {
       this.Brand = Brand;
       this.Size = Size;
   }

   public static void main(String[] args) {

       /* create an object */
       Shoes myshoes = new Shoes("nike", 10);
      
       /* print the values assigned to the instance variables */
       System.out.print("Brand - ");
       System.out.println(myshoes.Brand);
       System.out.print("Size - ");
       System.out.println(myshoes.Size);

       /* set myshoes reference to null */
       myshoes = null;

       /* request to garbage collector */
       System.gc();

   }

   /* @override the finalize method of 'Object' class */
   protected void finalize() throws Throwable {
       System.out.println("myshoes object is destroyed");
   }
}

You can also try this code with Online Java Compiler

Run Code

Output

Brand - nike
Size - 10
myshoes object is destroyed

We have a 'Shoes' class with two instance variables, "Brand" and "Size." The Constructor of this class takes two parameters. In the 'main()' function, when a 'myshoes' object is created, 'nike' is assigned to the 'Brand' instance variable, and '10' is assigned to the 'Size' instance variable. After that, we set the 'myshoes' reference to null so that it will no longer be accessible by any references in the program. Finally, we call the garbage collector by the 'system.gc()' function. Before the object is garbage collected, the garbage collector calls the 'finalize()' method. The 'finalize()' method is overridden in the 'Shoes' class as it is defined in the 'Object' class, which is a superclass of all other classes in Java. After the execution of the 'finalize()' method, the "my shoes" object will be destroyed, and the garbage collector will proceed with the actual garbage collection process.

Frequently Asked Questions

What is deconstructor in Java?

Java does not have a deconstructor. Instead, it employs automatic garbage collection to manage memory, eliminating the need for explicit destructors.

Does Java have a deconstructor?

No, Java does not have a deconstructor. Memory management is handled through automatic garbage collection, simplifying resource cleanup.

What is an example of a destructor?

Destructors are not used in Java. In languages like C++, an example is ~MyClass() for cleaning up resources when an object is destroyed.

What is the difference between constructor and destructor?

Constructors initialize objects during creation, while destructors (not present in Java) clean up resources when an object is destroyed or goes out of scope in languages like C++.

What is a destructor method?

A destructor method is a special function in object-oriented programming that is automatically invoked when an object is destroyed or goes out of scope, responsible for releasing resources and performing clean-up tasks for the object.

Conclusion

In this article, We have gone over the concept and implementation of java destructor. Java, with its automatic garbage collection mechanism, eliminates the need for explicit destructors. The absence of destructors simplifies memory management, promoting cleaner and safer code.

If you find any problems, please comment. We will love to answer your questions. Also, Attempt our Online Mock Test Series on Coding Ninjas Studio now!