final Keyword in Java - A Complete Guide

⏱️ 25 min read • Beginner to Intermediate • Lesson 60

The final keyword in Java restricts reassignment, overriding, or inheritance depending on where it is used.

You can apply final to variables, fields, parameters, methods, and classes. However, its exact meaning changes with the declaration. A final reference cannot point to another object, but the object it references may still be mutable.

What Is the final Keyword in Java?

final is a non-access modifier that applies a restriction to a declaration. It does not mean exactly the same thing everywhere: a final variable cannot be assigned again, a final method cannot be overridden, and a final class cannot be extended.

Three Main Uses of final

Final Variables

A final variable can be assigned only once. After initialization, another assignment causes a compilation error.

class FinalVariableExample {
    public static void main(String[] args) {
        final int passingMarks = 40;

        System.out.println(passingMarks);

        // passingMarks = 50; // Compilation error
    }
}

Output:

40

Blank Final Variables

A blank final field is declared without an initializer. Every constructor must assign it exactly once before construction finishes.

class Student {
    private final int rollNumber;
    private final String name;

    Student(int rollNumber, String name) {
        this.rollNumber = rollNumber;
        this.name = name;
    }

    void display() {
        System.out.println(rollNumber + " - " + name);
    }

    public static void main(String[] args) {
        Student student = new Student(101, "Ayan");
        student.display();
    }
}

Output:

101 - Ayan

Static Final Constants

A static final field belongs to the class and cannot be reassigned after initialization. Constants normally use uppercase words separated by underscores.

class AppConfig {
    static final int MAX_LOGIN_ATTEMPTS = 3;
    static final String APP_NAME = "ProwessApps";

    public static void main(String[] args) {
        System.out.println(APP_NAME);
        System.out.println(MAX_LOGIN_ATTEMPTS);
    }
}

Output:

ProwessApps
3

Final Local Variables

A local variable can be final. It may receive its value later, but only once along every valid execution path.

class LocalFinal {
    public static void main(String[] args) {
        final int result;

        if (args.length > 0) {
            result = 100;
        } else {
            result = 0;
        }

        System.out.println(result);
    }
}

Output:

0

Final Parameters

Declaring a method parameter final prevents reassignment of the parameter variable inside that method. It does not automatically make the passed object immutable.

class FinalParameter {
    static int square(final int number) {
        // number = 20; // Compilation error
        return number * number;
    }

    public static void main(String[] args) {
        System.out.println(square(5));
    }
}

Output:

25

Final Object References

A final reference cannot be changed to point to another object. However, the referenced object's mutable state may still change.

class Account {
    private double balance;

    void deposit(double amount) {
        balance += amount;
    }

    double getBalance() {
        return balance;
    }
}

class FinalReference {
    public static void main(String[] args) {
        final Account account = new Account();

        account.deposit(500);
        System.out.println(account.getBalance());

        // account = new Account(); // Compilation error
    }
}

Output:

500.0

Final Arrays and Collections

A final array reference cannot be replaced, but its elements can be changed. The same principle applies to mutable collections.

import java.util.Arrays;

class FinalArray {
    public static void main(String[] args) {
        final int[] values = {10, 20, 30};

        values[0] = 99;
        System.out.println(Arrays.toString(values));

        // values = new int[] {1, 2}; // Compilation error
    }
}

Output:

[99, 20, 30]

Final Methods

A final instance method is inherited but cannot be overridden. Use it when changing the algorithm in a subclass would violate a required rule or invariant.

class Payment {
    final void validateAmount(double amount) {
        if (amount <= 0) {
            throw new IllegalArgumentException(
                    "Amount must be positive");
        }
    }
}

class CardPayment extends Payment {
    void pay(double amount) {
        validateAmount(amount);
        System.out.println("Paid ₹" + amount);
    }

    // void validateAmount(double amount) { } // Error
}

Final Classes

A final class cannot be extended. This can protect a completed design, prevent subclass-based changes, or support immutability when combined with other design rules.

final class SecurityToken {
    private final String value;

    SecurityToken(String value) {
        this.value = value;
    }

    String getValue() {
        return value;
    }
}

// class CustomToken extends SecurityToken { } // Error

Can a Constructor Be final?

No. Constructors are not inherited and cannot be overridden, so applying final to a constructor would have no valid meaning. Constructors can be overloaded by using different parameter lists.

final vs abstract

final vs finally vs finalize()

final and Immutability

Final fields are important in immutable classes, but final alone does not guarantee immutability. Mutable objects must not be exposed directly, constructors must make defensive copies where needed, and mutator methods must be avoided.

final class StudentRecord {
    private final int rollNumber;
    private final String name;

    StudentRecord(int rollNumber, String name) {
        this.rollNumber = rollNumber;
        this.name = name;
    }

    int getRollNumber() {
        return rollNumber;
    }

    String getName() {
        return name;
    }
}

Effectively Final Variables

A local variable is effectively final when it is assigned once and never reassigned, even if the final keyword is omitted. Lambdas and local or anonymous classes can capture final or effectively final local variables.

class EffectivelyFinal {
    public static void main(String[] args) {
        String prefix = "Hello";

        Runnable task = () ->
                System.out.println(prefix + " Java");

        task.run();
        // prefix = "Hi"; // Would break effective finality
    }
}

Output:

Hello Java

Important final Keyword Rules

Best Practices

Tricky Cases

1. Can a final variable be initialized later?

2. Can a final reference modify its object?

3. Can a final method be overloaded?

4. Can a final class implement an interface?

5. Can a final class contain non-final methods?

6. Is final the same as const?

7. Does final make a program thread-safe?

Common Mistakes

Interview Questions ⭐

Test your understanding with a quick quiz

class Test {
    public static void main(String[] args) {
        final int value = 10;
        System.out.println(value);
    }
}

class Test {
    public static void main(String[] args) {
        final int value = 10;
        value = 20;
        System.out.println(value);
    }
}

class Test {
    public static void main(String[] args) {
        final int[] values = {10, 20};
        values[0] = 99;
        System.out.println(values[0]);
    }
}

Great job! Continue learning Java step by step.