What Does final Mean on Classes, Methods, and Variables?

final means different things depending on what it is attached to, but the common thread is that it removes the possibility of change.

On a class, final means the class cannot be subclassed. This is what makes a class's design guarantees real: if Point is final, nobody can extend it and override its methods to break the contract, and the compiler can inline its calls.

On a method, final means the method cannot be overridden by a subclass. It is used for methods that hold a critical invariant, and it lets the JIT compiler devirtualise the call.

On a variable — a local, a parameter or a field — final means the variable cannot be reassigned after its initial assignment. For a local or parameter, the assignment happens at declaration. For a blank final field, it must be assigned exactly once, and the compiler proves it happens on every path through every constructor, including the delegation path.

On a parameter, final is a promise not to reassign the parameter inside the method. It is a readability and bug-prevention device rather than a language-level guarantee, since a method could always write to the same object through a different reference.

public class Main {
    public static void main(String[] args) {
        // A final local: assigned once, never reassigned.
        final int limit = 10;
        System.out.println("limit      : " + limit);

        // A final reference: the reference cannot move, but the object can change.
        final StringBuilder sb = new StringBuilder("start");
        sb.append("-changed");
        System.out.println("final ref  : " + sb);

        Config c = new Config();
        System.out.println("name       : " + c.getName());
        c.retry();
        System.out.println("attempts   : " + c.getAttempts());
    }
}

final class Config {                     // cannot be subclassed
    private final String name = "prod";  // assigned once
    private int attempts;                // not final, so it can change

    public String getName() {
        return name;
    }

    public int getAttempts() {
        return attempts;
    }

    public void retry() {
        attempts++;
    }
}

class Base {
    final void cannotOverride() {       // cannot be overridden
        System.out.println("base method");
    }
}

Note that Config mixes both: its name is final and its attempts counter is not, so the class has one piece of state that never changes and one that does. The final class modifier means nobody can subclass it to break those guarantees.

final on a variable restricts reassignment of the variable, not mutation of the object it points at. A final field of a reference type is a fixed reference to an object whose contents may still change. That is the whole distinction, and it is where most surprises with final come from.

The practical examples. A final String cannot be reassigned, and because String is immutable that means the value can never change either. A final StringBuilder cannot be reassigned, but you can still call append on it, so the object it points at does change. A final collection field cannot be replaced with a different collection, but you can still add to it.

Why it matters is that final fields are the backbone of safe publication. A final field assigned in a constructor is guaranteed by the Java Memory Model to be visible to any thread that sees the object, even if the object was published without synchronisation. The reasoning is that the compiler cannot reorder a write to a final field past the end of the constructor, so a reader that observes the object must observe the correctly initialised final field. This is why immutable objects and final fields are the standard answer to the double-checked locking problem — in modern Java the usual fix is simply to make the field final and let the memory model do the work.

There is one caveat. If a constructor publishes this — by starting a thread or handing the reference to another object — the safe-publication guarantee does not extend to fields that are not final.

The practical advice for an interview: use final on every field you can, use final for local variables you want to freeze, and remember that final protects the reference, not the object.