The final Keyword in Java

The final keyword in Java means "this can't change". You can use it on variables (assign once), methods (no overriding), and classes (no subclassing). It makes code safer and easier to reason about, but there's one big misunderstanding about final that trips up nearly every beginner.

What does final mean in Java?

Think of writing in pen instead of pencil. Once something is written in pen, it stays. final is Java's pen, and you can apply it in five places:

final int maxPlayers = 4;
maxPlayers = 5;   // ✘ cannot assign a value to final variable

private final String id;

User(String id) {
    this.id = id;   // must happen exactly once
}

public static final int MAX_LOGIN_ATTEMPTS = 3;

public final boolean checkPassword(String input) {
    // subclasses can't replace this
}

public final class Money { }
class FakeMoney extends Money { }   // ✘ cannot inherit from final Money

Final variables: assign once

final double taxRate = 0.18;
taxRate = 0.20;     // ✘ compile error: cannot assign a value to final variable taxRate

A final variable doesn't need a value right away. It just needs exactly one assignment before it's used:

final String greeting;
if (hour < 12) {
    greeting = "Good morning";
} else {
    greeting = "Good afternoon";
}
// greeting is now fixed

Final fields and immutable objects

A final field without a value is called a blank final. Java forces every constructor to set it exactly once:

public class User {
    private final String id;          // blank final
    private final String email;

    public User(String id, String email) {
        this.id = id;
        this.email = email;
    }

    public String getId() { return id; }
}

With only final fields and no setters, a User can never change after it's created. That's an immutable object, which is safe to share anywhere, even between threads.

The big gotcha: final doesn't freeze the object

For object variables, final locks the reference (which object the variable points to), not the object itself:

final List<String> cart = new ArrayList<>();

cart.add("Apples");             // ✔ allowed: changing the list's contents
cart.add("Bread");
System.out.println(cart);

cart = new ArrayList<>();       // ✘ compile error: can't point cart at a different list

[Apples, Bread]

If you need a list that can't change, use an unmodifiable list:

List<String> days = List.of("Mon", "Tue", "Wed");
days.add("Thu");   // ✘ throws UnsupportedOperationException at runtime

Final methods: no overriding

A final method is inherited normally, but subclasses can't replace it. Use it for logic that must behave the same way for every subclass, like a security check:

class Account {
    public final boolean canWithdraw(double amount, double balance) {
        return amount > 0 && amount <= balance;
    }
}

class SneakyAccount extends Account {
    @Override
    public boolean canWithdraw(double amount, double balance) {   // ✘ compile error: overridden method is final
        return true;
    }
}

Final classes: no subclassing

A final class can't be extended. String is final, so nobody can create a FakeString that breaks the guarantee that strings never change. To allow only some subclasses, Java 17 added sealed classes. See inheritance in Java.

What is "effectively final"?

Lambdas and inner classes can only use local variables that never change after being assigned. You don't have to write final; if you never reassign the variable, Java treats it as effectively final:

String prefix = "Item: ";                       // never reassigned → effectively final
List.of("pen", "cup").forEach(x -> System.out.println(prefix + x));   // ✔ works

Item: pen
Item: cup

final vs finally vs finalize

Quick recap

What's next?

You've seen new on almost every page. Find out exactly what it does in the new keyword guide, or pair final with static for constants.