Final Keyword in Java with Example

'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:

Java final variables

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 attempt to change the value of the final variable, then we will get a compilation error.

It is mandatory to initialize a final variable either during declaration, in the constructor, or in the respective block. If we leave it uninitialized, then 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.

  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

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.

In Java, there are many classes that have final methods, and they are not overridden in subclasses. In the Java Object class, the notify() and wait() methods are the final methods.

  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();
    }
  }

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. In order to be considered a final class, a class must be complete in nature. That means that it cannot be abstract.

If we try to inherit a final class, then the compiler throws an error at compilation time.

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.

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

  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();
    }
  }

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();
    }
  }

BaseController - showCommonInfo()
CustomerController - getCustomerPersonalInfo()

Final Keyword in Java

Java final variables

Java final method

Java final class

Final classes help in provide security

Final Keyword - Interview Questions and Answers

Currently No Video available