Final Vs Finally Vs Finalize in Java

In Java, final, finally, and finalize are three distinct concepts, although their names might seem similar at first glance. Each of these terms has different uses and functionality in Java that we will see in this tutorial and understand with the help of examples.

In Java, final and finally are keywords, but finalize is a method of the java.lang.Object class.

👉 What is final keyword in Java?

final is a keyword or reserved word that can be used in Java programming to restrict or set the limitations of uses for variables, methods, and classes.

The final keyword is a non-access modifier that is used with the following for different purposes:

Let's see the examples below of uses of final keyword with variable, method and class in Java.

Example: final keyword with variable in Java

  class Candidate {
    // Final Instance Variable with assigned value
    final int age_limit = 18;	
    
    // Blank final Instance Variables
    final String min_edu_general;		// => Assigning value inside Constructor
    final String min_edu_reserved;		// => Assigning value inside Instance Block
    
    // Static Final Variable with assigned value
    static final float app_fee_in_INR = 500;
    
    // Blank static final variable
    static final String exam_city;		// => Assigning value inside Static Block
    
    // CONSTRUCTOR
    public Candidate() {
      min_edu_general = "GRADUATION";
    }
    
    // INSTANCE BLOCK
    {
      min_edu_reserved = "INTERMEDIATE";
    }
    
    // STATIC BLOCK 
    static {
      exam_city = "BANGALORE/BENGALURU";
    }
  }
    
  public class FinalVariableDemo {
    public static void main(String[] args) {
      
      // First printing static properties 
      System.out.println("Application Fee (INR) : " + Candidate.app_fee_in_INR);
      System.out.println("Examination City : " + Candidate.exam_city);
      
      // Invalid in Java will get COMPILATION ERROR.
      // Candidate.application_fee_in_INR = 700;		
      
      // Now, creating an object of the class and printing final instance variable
      Candidate object = new Candidate();
      
      // Invalid in Java will get COMPILATION ERROR.
      // object.age_limit = 20;	    
      System.out.println("Age Limit : " + object.age_limit);
      System.out.println("Min Qualification (General) : " + object.min_edu_general);
      System.out.println("Min Qualification (RESERVED) : " + object.min_edu_reserved);
    }
  }

Application Fee (INR) : 500.0
Examination City : BANGALORE/BENGALURU
Age Limit : 18
Min Qualification (General) : GRADUATION
Min Qualification (RESERVED) : INTERMEDIATE

Example: final keyword with method in Java

  class Parent {
    final void display() {
      System.out.println("Parent class display() method");
    }
  }
  class Child extends Parent {
    // Will get compile time error if try to override final method
    // void display() {}
  }
  
  public class FinalMethodExample {
    public static void main(String[] args) {
      Child object = new Child();
      object.display();
    }
  }

Example: final keyword with class in Java

  final class LoginController {
    void login() {
      System.out.println("LoginController - login() method");
    }
  }
  
  // We cannot extends final class
  // class Test extends LoginController {}
  
  public class FinalClassExample {
    public static void main(String[] args) {
      // Final classes are only called by their own object 
      LoginController object = new LoginController();
      object.login();
    }
  }

👉 What is finally keyword in Java?

Finally is a keyword that is used to create a block that contains a set of crucial statements. Finally block is attached to try-catch blocks.

finally block is always executed, whether an exception occurs or not. Therefore, it contains all the necessary statements that need to be executed, such as closing a connection or closing a file, etc.

finally keyword in Java example

  public class FinallyBlockExample1 {
    public static void main(String[] args) {
      try {
        System.out.println("Executing try block...");
        // code
      } catch (NullPointerException e) {
        System.out.println("Executing catch block..." + e);
      }
      // executed regardless of exception occurred or not
      finally {
        System.out.println("Executing finally block...");
      }
      System.out.println("Rest of the code after try/catch blocks... ");
    }
  }

Executing try block...
Executing finally block...
Rest of the code after try/catch blocks...

👉 What is finalize method in Java?

The finalize() method is a java.lang.Object class method: This is a special method in Java that is called by the garbage collector just before an object is reclaimed. This method can be overridden to perform cleanup tasks before an object is destroyed. However, its use is not recommended, as there is no guarantee when or if the garbage collector will call the finalize() method. Instead, we should use other mechanisms like ‘try-with-resources’ or explicit resource management for cleanup tasks.

finalize method in Java example

  public class FinalizeMethodExample {
    public static void main(String[] args) {
      String str = new String("Some text value");
      str = null;
      // Requesting JVM to call Garbage Collector
      System.gc();
      System.out.println("Main method ended =====");
    }
    // Defining the finalize method
    public void finalize() {
      System.out.println("Called the finalize() method");
    }
  }

What is difference between final finally and finalize in Java?

There are the following differences between final, finally and finalize as given in the below table:

Remember, final and finally are proactive measures, while finalize is a reactive one and should be used sparingly.

Key	final	finally	finalize
Type	Keyword	Keyword	Method
Uses	Used to restrict or limit the uses of variables, methods, and classes.	Used to create a block of code that follows a try or catch block.	Used just before an object is destroyed and can be called just prior to object creation.
Applicable	With variables, methods, and classes	Associated with try-catch block in exception handling.	Used with the objects.
Functionality	Variables that are marked as final cannot be reassigned. Methods cannot be overridden once they have been marked as final. Classes marked as final, can’t be extended.	The finally block closes all the resources that were opened as a part of the try block.	Prior to destroying an object, the finalize method performs cleaning activities.
Execution	Always during initialization/declaration	Always after try-catch block	When garbage collector decides
Recommendation	Preferred for immutability and performance	Use for resource management	Avoid for cleanup