Introduction to Finalize in Java
Finalize is a method in Java. This finalizes () method is similar to the main method. This finalizes () method is called just before the object is garbage collected. It means the original object’s last chance to perform cleanup activities like releasing system resources, closing connections like database, file open connection, etc. The main problem with the finalize method is there is no guarantee by Java Language Specification (JLS) that will be called by garbage collector or when it will be called. Let’s consider an example that an object may wait up to an indefinite time after the object becomes eligible for garbage collection. It means before its finalize() method is called. Same way, after finalizing the method called it is no guarantee, it will be immediately collected. So there is no sense to perform critical activities inside the finalize() method. It may work in one JVM, and it may not work in other JVM at the time of development.finalize() method is available inside java.lang.Object so that it is automatically available to all the classes for overriding as Object is the classes’ base class.
How does the finalize() method work in Java?
This finalizes () method is called before an object is garbage collected, so it means we can’t call finalize() method manually just like other Java methods. finalize() method called only once by garbage collector(GC) thread.
Code:
protected void finalize throws Throwable
{
//write some code
}The finalize() method has an empty implementation, and in our class, clean-up activities are present, then we have to override this finalize() method to define our cleanup activities.
Examples to Implement Finalize in Java
Below are some examples mentioned:
Example #1
Finalize method user overriding method example
Code:
Main.java
//creating class
public class Main {
//main method for run the Java application
public static void main(String[] args)
{
//Creating String object with some content
String string = new String("I am Amardeep");
//make the string reference to null for allow it for Garbage Collection
string = null;
// Calling gc method for Garbage Collection
System.gc();
//displaying some message to the user
System.out.println("\tI am in Main method");
}
//We are Overriding finalize method.
public void finalize()
{
//displaying some message to the user
System.out.println("\tI am feeling that I am Overriding finalize method");
}
}Output:
Explanation: If you observe the above output, you might be surprised that you did not finalize the overriding method. If you closely observe the code that is not actual Java given overridden method, it is just like a user-created method as we know actual finalize method signature protected void finalize(). So we did not get this in the output.
Example #2
Finalize method overriding actual method example
Code:
Main.java
//creating class
public class Main {
//main method for run the Java application
public static void main(String[] args)
{
//Creating Main object
Main main = new Main();
//make the main reference to null for allow it for Garbage Collection
main = null;
// Calling gc method for Garbage Collection
System.gc();
//displaying some message to the user
System.out.println("\tI am Amardeep from main method");
}
//We are Overriding finalize method.
@Override
protected void finalize()
{
//displaying some message to the user
System.out.println("\tI am actaully Overriding now.");
}
}Output:
Explanation: As we see in the above output, we finalize() method output because of overriding the actual finalize() method.
Example #3
Finalize method from finally block example
Code:
Main.java
//creating class
public class Main {
//main method for run the Java application
public static void main(String[] args)
{
//Creating Main object
Main main = new Main();
//make the main reference to null for allow it for Garbage Collection
main = null;
// Calling gc method for Garbage Collection
System.gc();
//displaying some message to the user
System.out.println("\tI am Amardeep from main method");
}
//We are Overriding finalize method.
@Override
protected void finalize() throws Throwable {
try{
//displaying some message to the user
System.out.println("\tFinalize of Paramesh");
}catch(Throwable t){
throw t;
}finally{
//displaying some message to the user
System.out.println("\tCalling finalize from finally block");
super.finalize();
}
}
}Output:
Example #4
Finalize method not guaranteed example
Code:
FinalizeNotGuarantee.java
//package com.finalize;
public class FinalizeNotGuranteed implements Runnable {
//user defined method
private void getMyMethod() throws InterruptedException {
//try block
try {
System.out.println("Hi, I am TRY");
throw new NullPointerException();
//catch block
} catch (NullPointerExceptionnpe) {
System.out.println("Hi, Iam CATCH");
//finally block
} finally {
System.out.println("Hi, I am FINALLY");
}
}
//overriding finalize method
@Override
protected void finalize() throws Throwable {
System.out.println("I am kinside finalize block");
super.finalize();
}
//overriding Thread run method
@Override
public void run() {
try {
getMyMethod();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
public static void main(String[] args) {
for (int i = 1; i<= 3; i++) {
//start the thread method run by using start method
new Thread(new FinalizeNotGuranteed()).start();
}
}
}Output:
Explanation: The above example clearly illustrates that the finalize method not always guarantee to execute.
Conclusion
Java finalizes () method is used to collect the garbage collected object. This method is called just before the GC() method is called. This method is not always guaranteed to execute.
Recommended Articles
This is a guide to Finalize in Java. Here we discuss an introduction to the Finalize in Java, how it works, and examples for better understanding. You can also go through our other related articles to learn more –
