Java final Keyword With Examples

Previous Page
Next Page

Java final keyword

final is a reserved keyword dedicated to restricting customization to the member/entity it is tagged to. It is a non-access modifier which is applicable to class and its members(variables and methods). With common intention to restrict customization, it behaves differently according to tagged member/entity.

We will look at the use of final keyword with the followings.

  • Class
  • Variables
  • Methods

final keyword with class

Using final with class prevents it to get inherited by any other class. The reason for making a class final can have two reasons:

  • Restrict inheritance.  Once declared final, a class cannot be extended.
  • Create an Immutable class. It means that once the object is created, it cannot be changed. It is used in a concurrent environment to avoid any change in the object in synchronized blocks.

Example:

final class Parent{
   int parVal;
}

class Child extends Parent{
    int childVal;
}

public class ClassMain{
    public static void main(String args[]){
        Child obj = new Child();
    }
}

Output:

ClassMain.java:5: error: cannot inherit from final Parent
class Child extends Parent{
                    ^
1 error

final keyword with variables

Using final with a variable, makes it a constant, un-modifiable after its first assignment. It is important to initialize the final type variable by any of the following ways in order to avoid a compile-time error.

  1. Initialize right at the time of its declaration.
  2. Create a static block and initialize them.
  3. Initialize the variable inside every version of the constructor.
  4. Create an anonymous block/instance initializer block and initialize variables in it.

It is a convention to only use uppercase for the name of final variables to be identified easily.

Example:

class MyClass{
   //Version 1: Initialize right at the time of its declaration
   final int FINALVAR1=10;
   static final int FINALVAR2; //It is static, so that static block can refer and use it.
   final int FINALVAR3;
   final int FINALVAR4;

   //Version 2:     Create a static block and initialize them
   static{
       FINALVAR2 = 20;
   }
   //Version 3:     Initialize the variable inside every version of constructor
   MyClass(int initFinalVar){
       FINALVAR3 = initFinalVar;
   }
    //Version 4: Create an anonymous block/instance initializer block and initialize variables in it
   {
       FINALVAR4= 40;
   }
}

public class ClassMain{
    public static void main(String args[]){
        MyClass obj = new MyClass(30);
        System.out.println("FINALVAR1 = "+obj.FINALVAR1);
        System.out.println("FINALVAR2 = "+obj.FINALVAR2);
        System.out.println("FINALVAR3 = "+obj.FINALVAR3);
        System.out.println("FINALVAR4 = "+obj.FINALVAR4);

    }
}

Output:

FINALVAR1 = 10
FINALVAR2 = 20
FINALVAR3 = 30
FINALVAR4 = 40

Now let us try changing the values.

class MyClass{
   //Version 1: Initialize right at the time of its declaration
   final int FINALVAR1=10;
   static final int FINALVAR2; //It is static, so that static block can refer and use it.
   final int FINALVAR3;
   final int FINALVAR4;

   //Version 2:     Create a static block and initialize them
   static{
       FINALVAR2 = 20;
   }
   //Version 3:     Initialize the variable inside every version of constructor
   MyClass(int initFinalVar){
       FINALVAR3 = initFinalVar;
   }
    //Version 4: Create an anonymous block/instance initializer block and initialize variables in it
   {
       FINALVAR4= 40;
   }
}

public class ClassMain{
    public static void main(String args[]){
        MyClass obj = new MyClass(30);
        System.out.println("(BEFORE)FINALVAR1 = "+obj.FINALVAR1);
        System.out.println("(BEFORE)FINALVAR2 = "+obj.FINALVAR2);
        System.out.println("(BEFORE)FINALVAR3 = "+obj.FINALVAR3);
        System.out.println("(BEFORE)FINALVAR4 = "+obj.FINALVAR4);

        obj.FINALVAR1++;
        obj.FINALVAR2++;
        obj.FINALVAR3++;
        obj.FINALVAR4++;

        System.out.println("(AFTER)FINALVAR1 = "+obj.FINALVAR1);
        System.out.println("(AFTER)FINALVAR2 = "+obj.FINALVAR2);
        System.out.println("(AFTER)FINALVAR3 = "+obj.FINALVAR3);
        System.out.println("(AFTER)FINALVAR4 = "+obj.FINALVAR4);

    }
}

Output:

ClassMain.java:35: error: cannot assign a value to final variable FINALVAR1
        obj.FINALVAR1++;
           ^
ClassMain.java:36: error: cannot assign a value to final variable FINALVAR2
        obj.FINALVAR2++;
           ^
ClassMain.java:37: error: cannot assign a value to final variable FINALVAR3
        obj.FINALVAR3++;
           ^
ClassMain.java:38: error: cannot assign a value to final variable FINALVAR4
        obj.FINALVAR4++;
           ^
4 errors

final keyword with methods

Using final with methods, makes it override resistant. After inheriting a parent class, the child class can override the inherited methods. In order to restrict overriding to the inherited method, we use the final methods.

Example:

class Parent{
    final void printDetails(){
    System.out.println("I am parent version and cannot be overridden ");  
   }
}

class Child extends Parent{
    @Override
    void printDetails(){
    System.out.println("I am child version and will result in compile error"); 
   }
}

public class ClassMain{
    public static void main(String args[]){
        Parent obj = new Parent();
        obj.printDetails();

        obj = new Child();
        obj.printDetails();
    }
}

Output:

ClassMain.java:9: error: printDetails() in Child cannot override printDetails() in Parent
void printDetails(){
     ^
overridden method is final
1 error

Example 2:

This example illustrates that the final method is inherited but as an override-resistant method

class Parent{
    final void printDetails(){
    System.out.println("I am parent version and cannot be overridden ");  
   }
}

class Child extends Parent{
}

public class ClassMain{
    public static void main(String args[]){
        Parent obj = new Parent();
        obj.printDetails();       

        obj = new Child();
        obj.printDetails();
    }
}

Output:

I am parent version and cannot be overridden
I am parent version and cannot be overridden

This was an overview of the final keyword. We will discuss the Java Abstract classes and methods in the next lecture.

Previous Page
Next Page