Final Keyword in Java

Last Updated: 12 November, 2024    |    🕓  7 Mins Read

The final keyword is a non-access modifier used in Java programming to limit the use of variables, methods, and classes.

The final keyword is used with the following for different purposes:

1. Variables marked as final can't be reassigned.
2. Methods marked as final, they cannot be overridden.
3. Class marked as final, can’t be extended.

Java final variable

In Java, when a variable is declared with the final keyword, it's known as a final variable, and its value can’t be changed once it's initialized with some value. If we change the value of the final variable then the compiler will throw an error at the compile-time of the program.

It is mandatory to initialize a final variable either during declaration or in the constructor, or in the respective block otherwise we will get a compilation error.

Let's have a look below at the implementation of the final variable with instances and the static variable.

Example 1 : Final 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);
    }
  }
  

Output

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

Java final method

In Java, a method declared with the final keyword is called the final method. A final method can't be overridden in subclasses. The JVM applies restrictions to the method.

Java has so many inbuilt classes, and some of the inbuilt classes contain final methods; these final methods we cannot override in the subclasses, for example, java.lang.Object class contains notify() and wait() methods as final methods.

Example 2 : Final 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();
    }
  }
  

Output

Parent class display() method

Java final class

As its name suggests, a final class is declared using the final keyword. A final class cannot be inherited by subclasses. We can restrict the inheritance of classes by using the final class. During the compile-time, if compiler found any class is inheriting a final class, it will throw an error.

A final class must be a complete class; its functionality should meet the requirement. A final class never be an abstract class in Java.

Final classes help in provide security

Using the final classes, we can protect confidential information from unauthorized access. Suppose we have a non-final class that has some confidential data that must be accessed by only authorized people, but a hacker can inherit that non-final class in a subclass and steal confidential data or alter the business logic of the class. We can prevent this and provide security for important classes in the Java project. Therefore, we should always declare such classes with the 'final' keyword so that no one can inherit them.

There are some popular final classes provided by Java

All Wrapper Classes (such as Integer, Boolean, Character, etc.), String, StringBuffer, StringBuilder, System, Math, StrictMath, Formatter, Void, etc.

Example 3 : Final 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();
    }
  }
  

Output

LoginController - login() method

Example 4 : The final class can extend another class in Java

For example, in Java, a final class can extend another class, whether that class is a normal class or an abstract class. Let's see the example below for better understanding:

  class BaseController {
    void showCommonInfo() {
      System.out.println("BaseController - showCommonInfo()");
    }
  }
  
  // A final class can extend another class
  final class CustomerController extends BaseController {
    void getCustomerPersonalInfo() {
      System.out.println("CustomerController - getCustomerPersonalInfo()");
    }
  }
  
  public class FinalClassExample2 {
    public static void main(String[] args) {
      // Final class is only called by their own object
      CustomerController object = new CustomerController();
      object.showCommonInfo();
      object.getCustomerPersonalInfo();
    }
  }

Output

BaseController - showCommonInfo()
CustomerController - getCustomerPersonalInfo()