In this tutorial, we will learn final keyword in Java. We will discuss three places such as Variable, method, and class where the final keyword can be used.

The final keyword declared with variable, method, and class indicates that “This cannot be modified”. The value of the final variable cannot be changed. A final method cannot be overridden. A final class cannot be inherited.

Let’s understand the following topics under this tutorial.

Final Keyword in Java

Final is a keyword that is used to restrict the user in Java programming. It is a non-access modifier that is only applicable to a variable, method, or class.

Java Final keyword has three different uses:
1. To create constant.
2. To prevent inheritance.
3. To prevent method from being overridden.

Final Variable in Java

A variable declared with a final keyword is known as a final variable in Java. Final variable means a constant (value cannot be modified). When the final variable once initialized, the value of the final variable can never be changed. In other words, we cannot be assigned a new value.

Declaration of Final variable in Java

The final variable must be declared at a time of declaration otherwise, it will give a compilation error. The syntax to declare a final variable in Java is as follows:
Syntax:

final data_type variable_name = value; //Just add a final keyword in front of definition.

For example:

final Float pi = 3.14f;

Since the final variable means constant. Therefore, we cannot change the value of pi.

float pi = 6.14f // compilation error.

A final keyword can be applied to local variables, instance variables, and static variables. In all cases, it does the same thing. Once you initialized the value of a final variable, you cannot assign a new value.

Java Final Variable Example Program

Let’s create an example program where we will try to change the value of final instance variable and final local variable but it can’t be changed because the final variable once initialized a value can never be changed. Look at the following source code.

Program source code 1: 

package finalPrograms; 
public class FinalVariableEx 
{ 
// Declare a final instance variable. 
    final int a = 20; 
// Declare an instance method. 
    void change()
    { 
// Change the value of the final instance variable. 
      a = 40; // compile time error. A final variable's value cannot be changed. 
     System.out.println(a); 

// Declare a final local variable inside the method. 
     final int i = 0; 
     for(i=0; i

Output: 
       Exception in thread "main" java.lang.Error: Unresolved compilation problems: The final field FinalVariableEx.a cannot be assigned The final local variable i cannot be assigned. It must be blank and not using a compound assignment The final local variable i cannot be assigned. It must be blank and not using a compound assignment

Explanation:

We got a compilation error problem in the above program because we tried to change the value of final variables a and i. A final variable that is created inside the constructor, method, or block is known as a local final variable. It must be initialized once where it is created.

You can see the above example program where we have declared a final local variable inside the method.

When to use Final variable in Java?

A final variable can be used where we want to remain constant the value of a variable throughout the execution of a program.

Key points:
The only difference between a normal variable and a final variable is that we can re-assign value to a normal variable but we cannot re-assign the value of a final variable once assigned.

Blank Final Variable in Java

A variable that is declared as final and not initialized at a time of declaration is known as a blank final variable in Java. A blank final variable must be initialized in the constructor of the class otherwise we will get a compilation error. Once the final variable is initialized in the constructor, it cannot be assigned a new value.

For example:

class Test 
{ 
 // Declaration of final instance variable. 
     final int x; 
     Test()
     { 
       // Initialization of final variable in the constructor. 
           x = 20; 
      } 
 }

Uninitialized Static Blank Final Variable

When a blank final variable is declared as static and not initialized at a time of declaration, it can only be initialized in the static block. It cannot be initialized in the constructor of the class. Let’s take an example program based on this concept.

Program source code 2:

package finalPrograms; 
public class FinalVar 
{ 
// Declare a blank final instance variable. 
    final int x; 

// Declare a static blank final variable. 
    final static int a; 
    FinalVar()
    { 
      x = 30; 
    } 
 void displayValue()
 { 
    System.out.println("Value of x: " +x); 
 } 
// Declare a static block to initialize the final static variable. 
    static 
    { 
      a = 20; 
      System.out.println("Value of a: " +a); 
    } 
 public static void main(String[] args) 
 { 
// Create an object of the class. 
    FinalVar fv = new FinalVar(); 

// Call change() method using reference variable fv. 
     fv.displayValue(); 
   } 
 }

Output: 
       Value of a: 20 
       Value of x: 30

Reference Final Variable in Java

A final variable that is declared as a reference to an object is known as reference final variable. There is nothing like a final object in Java.

If a final reference variable refers to an object then it does not mean that the object is final. It simply means that the reference variable cannot refer to another object.

For example:
A final List reference variable looks like this:

final List list; // Here, list is variable of type List.

Here, the list is final. It does not mean that elements cannot be added or removed from the list. The final list means the reference variable cannot refer to any new ArrayList. Any attempt to do so we will get compile-time error.

Let’s take an example program where we will declare the reference of a list as final. This final reference variable cannot be used to refer new ArrayList object.

Program source code 3:

package finalPrograms; 
import java.util.ArrayList; 
import java.util.List; 
public class FinalReferenceVarEx 
{ 
 public static void main(String[] args) 
 { 
// Create an object of the list and declare as a final. 
    final List list = new ArrayList(); 

// Adding elements in the list. 
     list.add(20); 
     list.add(30); 
     list.add(40); 
   System.out.println("Elements in the list"); 
   System.out.println(list); 
   
   list = new ArrayList(); // Final local variable 'list' cannot refer to new ArrayList object. 
  } 
}

Output: 
       Exception in thread "main" java.lang.Error: Unresolved compilation problem: The final local variable list cannot be assigned. It must be blank and not using a compound assignment

If you have not learned ArrayList in Java then you can skip this program. When you will learn ArrayList, you can easily understand this program.

Can we change state of object to which a final reference is pointing?

Yes, we can change the state of an object to which a final reference variable is pointing but we cannot re-assign a new object to this final reference variable.

Final Method in Java

package finalPrograms; 
public class FinalMethodEx 
{ 
 FinalMethodEx()
 { 
    System.out.println("This is a default constructor"); 
 } 
  final int a = 50; 
  final void show()
  { 
     System.out.println("Value of a: " +a); 
   } 
 } 
public class FinalMethodExTest extends FinalMethodEx
 { 
   void show()
   { 
  // Compile time error because we cannot override the final method from FinalMethodEx. 
     System.out.println("This is the final method of FinalMethodEx class"); 
   }
 public static void main(String[] args)   
 { 
// Create an object of FinalMethodEx class. 
    FinalMethodEx fm = new FinalMethodEx(); 

// Call final method using reference variable fm. 
      fm.show(); 
   } 
}

Output: 
        This is a default constructor 
        Value of a: 50

package finalPrograms; 
public class FinalParameterEx 
{ 
 final String nSchool; 
 
 FinalParameterEx()
 { 
    nSchool = "RSVM"; 
    System.out.println("School name: " +nSchool); 
 } 
 void msg(final String name)
{ 
   name = "Lava"; // Compile time error because the final local variable cannot be changed. 
 } 
public static void main(String[] args) 
{  
   FinalParameterEx fp = new FinalParameterEx(); 
    fp.msg("Shubh"); 
 } 
}

Output: 
       School name: RSVM 
       Exception in thread "main" java.lang.Error: Unresolved compilation problem: The final local variable name cannot be assigned.

public final class Student 
{
 // class contents
}

public class Student 
{
 private Student(final int x) 
 { 
   . . . . . .               
 }
}

package finalPrograms; 
public final class AB 
{ 
  void show()
  { 
     System.out.println("Final class cannot be inherited"); 
  } 
 } 
public class ABTest extends AB { // Here compile-time error because the final class cannot be extended. 
   public static void main(String[] args) 
   { 
 // Create the object of class AB. 
      AB ab = new AB(); // Call show() method using object reference variable ab. 
      ab.show(); 
    } 
 }

Output: 
       Compile time error

package finalPrograms; 
public class AB 
{ 
// Declare a default constructor as private to make a class as final. 
    private AB()
    { 

     } 
 void show()
 { 
    System.out.println("Final class cannot be inherited"); 
 } 
} 
public class ABTest extends AB { // Here compile time error because Implicit super constructor AB() is not visible for default constructor. Must define an explicit constructor.

public static void main(String[] args) 
{ 
// Create the object of class AB.
    AB ab = new AB(); // compile time error because the constructor AB() is not visible. 

// Call show() method using object reference variable ab. 
      ab.show(); 
   } 
}

Output: 
       Compile time error

The post Final Keyword in Java | Final Variable, Method & Class appeared first on Scientech Easy.