Constants (final keyword) in Java

Analogy categoryAnalogies

1. Introduction

A constant is a value that cannot be changed once it has been assigned. In Java, constants are created using the final keyword applied to a variable. Once a final variable is assigned a value, any attempt to reassign it results in a compile-time error.

🏏

Cricket analogy: The fixed boundary rope distance set before a match at a venue like the MCG cannot be moved once play begins; any attempt to shift it mid-match would be rejected, just as reassigning a final variable in Java triggers a compile-time error.

Constants are commonly used for fixed values such as mathematical constants, configuration values, or limits that should never change during program execution, improving code readability and preventing accidental modification.

🏏

Cricket analogy: The fixed value of a boundary being worth exactly 4 runs (or 6 if it clears the rope) never changes across any match worldwide, giving every scorer and fan a reliable, unchangeable reference point, just like final constants in code.

2. Syntax

java

final dataType CONSTANT_NAME = value;

final double PI = 3.14159;
final int MAX_USERS = 100;
static final String APP_NAME = "SkillVeris";  // class-level constant

3. Explanation

When final is applied to a variable, it becomes assign-once: it must be given a value either at declaration or in the constructor (for instance variables), and after that first assignment, it cannot be reassigned. By convention, constant names are written in UPPER_SNAKE_CASE, e.g., MAX_VALUE. Constants that belong to the class rather than any specific object are typically declared as static final so only one copy exists and it can be accessed without creating an object.

🏏

Cricket analogy: A player's jersey number, like Sachin Tendulkar's iconic 10, is assigned once at the start of his career and never reassigned, and just as retired jersey numbers are written in bold capital letters on stadium walls, static final constants like MAX_OVERS exist as one shared copy across the whole team.

The final keyword is not limited to variables. When applied to a method, final prevents that method from being overridden by a subclass. When applied to a class, final prevents that class from being extended (subclassed) at all — for example, the built-in String class is final, so it cannot be subclassed.

🏏

Cricket analogy: A franchise's core team motto, once declared unchangeable by ownership, can't be reworded by any coach who joins later, similar to how a final method can't be overridden; and just as the BCCI itself can't be 'forked' into a rival governing body, a final class like String can't be subclassed.

Exam trap: for a final reference variable (e.g., a final array or object), you cannot reassign the reference itself, but you CAN still modify the internal state of the object it points to. final only locks the reference, not the object's contents.

4. Example

java

public class ConstantsDemo {
    static final double PI = 3.14159;

    public static void main(String[] args) {
        final int MAX_ATTEMPTS = 3;
        System.out.println("PI = " + PI);
        System.out.println("MAX_ATTEMPTS = " + MAX_ATTEMPTS);

        final int[] scores = {90, 85, 70};
        scores[0] = 95;  // allowed: modifying array content, not the reference
        System.out.println("Updated score: " + scores[0]);

        // MAX_ATTEMPTS = 5; // would cause a compile-time error if uncommented
    }
}

5. Output

text

PI = 3.14159
MAX_ATTEMPTS = 3
Updated score: 95

6. Key Takeaways

The final keyword creates constants — variables that can be assigned only once.
Reassigning a final variable after its first assignment causes a compile-time error.
static final is the standard way to declare a class-level constant.
final on a method prevents overriding; final on a class prevents inheritance.
final on a reference variable locks the reference, not the internal state of the referenced object.
Constant names conventionally use UPPER_SNAKE_CASE.