Java Final Keyword

Some things, once decided, must not change: your date of birth on a certificate, the rules of a signed contract. Java's final keyword locks things in the same way. It has three meanings depending on where you put it: on a variable it means "assign once", on a method it means "can't be overridden", and on a class it means "can't be extended". The lesson "Constants in Java" introduced the first; this lesson covers all three.

Three Kinds of final

final Variables in a Class

public class Pan {
    static final class PanCard {
        static final int LENGTH = 10;
        private final String number;
        private final String holder;
 
        PanCard(String number, String holder) {
            this.number = number;
            this.holder = holder;
        }
 
        String masked() {
            return "XXXXXX" + number.substring(6, LENGTH);
        }
    }
 
    public static void main(String[] args) {
        PanCard card = new PanCard("ABCDE1234F", "Srihitha Anamaneni");
        System.out.println(card.holder + ": " + card.masked());
    }
}

Srihitha Anamaneni: XXXXXX234F

How it works

1. Line 3: static final is a constant, one value for the class (see "Blank Final and Static Final Variables").
2. Lines 4 and 5: final instance fields must be assigned exactly once, here in the constructor, and can never change afterwards.
3. Line 2: the class itself is final, so nobody can create a subclass that changes how a PAN card behaves.

Try it yourself: add a method void rename(String n) { holder = n; }. What does the compiler say?

final Methods and final Classes

These two are about inheritance (see "Inheritance in Java"), so here are the errors you'll meet:

FinalM.java:2: error: show() in C cannot override show() in P
class C extends P { void show() {} }
                         ^
  overridden method is final
FinalC.java:2: error: cannot inherit from final P
class C extends P {}
                ^

A final method lets a class keep a rule fixed, such as how a fee is calculated, while still allowing subclasses for other things. A final class stops all subclassing. String, Integer and all the wrapper classes are final, so nobody can create a sneaky subclass of String that behaves differently.

final Is Not Immutable

final on a reference stops reassignment, not changes to the object (see "Constants in Java"):

public class Seats {
    public static void main(String[] args) {
        final int[] booked = {0, 0, 0};
        booked[1] = 1;
        System.out.println(java.util.Arrays.toString(booked));
    }
}

[0, 1, 0]

booked = new int[3]; wouldn't compile, but changing the array's contents is fine. An immutable object, like String or the PanCard above, is one with private final fields and no methods that change them (see "How to Create an Immutable Class in Java").

final Parameters and Locals

final also works on parameters and local variables: void book(final String name). It stops accidental reassignment inside the method. Local variables used inside lambdas (covered later in the course) must be effectively final: never reassigned, even without the keyword.

Common Mistakes

Thinking final makes an object read-only. It only fixes the reference.

Leaving a final field unassigned. Every constructor must assign it exactly once (see the next lesson).

Confusing final, finally and finalize. finally is a block in exception handling (covered later in the course); finalize was an old, now deprecated, cleanup method.

Interview Corner

Practice

1. Easy: Make a Student class with a final roll number set in the constructor, and show that it can't be changed later.
2. Harder: Write a final class Money with private final rupees and paise fields and a method plus(Money other) that returns a new Money instead of changing either object.

Key Takeaways