Blank Final in Java

In Java, the final keyword is used to declare constants, prevent method overriding, and inheritance. A special use case of the final keyword is the "blank final" variable. A blank final variable is a final variable that is not initialized during declaration but is assigned a value later. In this section, we will discuss the intricacies of blank final variables, their usage, and the rules governing them.

Final Variables

Before exploring blank final variables, it is crucial to understand the basic concept of final variables. A final variable can be assigned only once and cannot be modified thereafter. This makes it effectively a constant.

In the above example, CONSTANT is a final variable, initialized at the time of declaration.

What is a Blank Final Variable?

A blank final variable is a final variable that is declared but not initialized at the point of declaration. The initialization of a blank final variable must occur before the constructor completes its execution.

File Name: BlankFinal.java

class Example {
    final int blankFinal;
	BlackFinal (int value) {
        this.blankFinal = value; // Initialization of blank final variable
    }
}   

In this example, blankFinal is a blank final variable. It is declared as final but not initialized at the point of declaration. Instead, it is assigned a value within the constructor.

Rules for Blank Final Variables

Initialization Requirement: A blank final variable must be initialized exactly once before the constructor completes. Failing to do so results in a compilation error.
No Reassignment: Once a blank final variable is initialized, it cannot be reassigned. Attempting to reassign it will lead to a compilation error.
Static Blank Final Variables: Static blank final variables follow similar rules but must be initialized in a static block.

Example of Blank Final Variable

Here is an example to demonstrate the usage of blank final variables:

File Name: BlankFinal.java

class Car {
    final String model;
    final int year;
    // Constructor to initialize blank final variables
    Car(String model, int year) {
        this.model = model;
        this.year = year; // Initialization of blank final variables
    }
    // Method to display car details
    public void displayDetails() {
        System.out.println("Model: " + model);
        System.out.println("Year: " + year);
    }
}
public class BlankFinal {
    public static void main(String[] args) {
        Car car = new Car("Tesla", 2021);
        car.displayDetails();
    }
}    

Output:

 
Model: Tesla
Year: 2021

Explanation

In this example, model and year are blank final variables in the Car class. They are initialized in the constructor and cannot be reassigned thereafter.

Static Blank Final Variables

Static blank final variables are declared as static and final but are not initialized at the point of declaration. They must be initialized in a static block.

File Name: Test.java

class Config {
    static final int MAX_USERS;
    static final String VERSION;
    static {
        MAX_USERS = 100;
        VERSION = "1.0"; // Initialization of static blank final variables
    }
    public static void displayConfig() {
        System.out.println("Max Users: " + MAX_USERS);
        System.out.println("Version: " + VERSION);
    }
}
public class Test {
    public static void main(String[] args) {
        Config.displayConfig();
    }
}   

Output:

 
Max Users: 100
Version: 1.0

Explanation

Static blank final variables that are specified as final and static but are not initialised at the time of declaration, are used in this example by the Config class. Rather, they are set up inside a static block. When the class is first put into memory, the static block is called, making sure that the variables are assigned values before they are utilised. Both the text "1.0" for VERSION and the number 100 for MAX_USERS are static final variables in the Config class. The static block initialises these variables. The values of these variables are printed by the static displayConfig method.

Advantages of Blank Final Variables

Flexibility: Blank final variables provide flexibility in initialization, allowing values to be assigned based on constructor parameters or static blocks.
Immutability: They ensure immutability once initialized, making the code more predictable and less prone to errors related to variable reassignment.
Readability and Maintainability: Using blank final variables improves code readability and maintainability by clearly indicating which variables are intended to remain constant.

Conclusion

Java's blank final variables provide an effective way to define constants that need to have their initialization delayed. They guarantee that once a value is assigned, it stays consistent for the duration of the object's or class's lifecycle by adhering to stringent initialization guidelines.

These are a crucial tool for creating reliable and manageable Java code. Comprehending and utilising blank final variables can result in programmes that are more consistent and error-free, improving the overall calibre of the codebase.

Next TopicBoggle-search-problem-in-java

← prev next →