Skip to main content
Sign in Create a free account
Varsity Tutors
Sign in
Back to lessons

Java • Syntax and Core Types

Final Constants — Use final constants appropriately

Learn how the final keyword locks values in place and makes your Java programs safer and more readable.

Explore the lesson 12 min read
Java programming emblem with a coffee cup, code braces, and terminal
Inside this lesson 10 sections 5 questions 7 figures

SECTION 1

Historical Context & Motivation

Long before Java existed, programmers discovered a frustrating problem: values that should never change sometimes got changed by accident. Imagine writing a physics simulation where someone accidentally sets the speed of light to 42. That kind of bug is extremely difficult to track down because the code compiles and runs, but produces wildly wrong results. Early programming languages like C addressed this with the const keyword, and when James Gosling and his team designed Java in the early 1990s, they included the final keyword to give programmers a way to declare values that the compiler would protect from modification.

1972 • C Language and #define

The C programming language used preprocessor macros (#define) to create constants. These worked but offered no type safety, leading to subtle bugs.

1983 • C++ Introduces const

C++ introduced the const keyword, giving constants real type checking at compile time. This was a major improvement for code safety.

1995 • Java 1.0 Ships with final

Java launched with the final keyword, which could apply not only to variables but also to methods and classes — a broader concept than C++ const.

2004 • Java 5 and Enums

Java 5 added enums, providing another way to represent fixed sets of constants. However, final remained essential for individual constant values.

2017+ • Modern Java Best Practices

Modern style guides (Google, Oracle) strongly recommend using final for all constants. The var keyword in Java 10 renewed interest in when and where to use final.

The core question this lesson addresses is straightforward: how do you declare a value in Java so that no part of your code can ever change it, and when should you actually do this? Understanding final constants is one of those skills that separates beginners from confident Java programmers.

SECTION 2

Core Principles & Definitions

A constant is a value that is assigned once and never modified again. In Java, you create a constant by placing the final keyword before a variable declaration. Once a final variable receives its value, any attempt to reassign it triggers a compile-time error, meaning the program will not even build. This protection catches mistakes before your code ever runs.

1

The final Keyword

Placed before a variable's type to prevent reassignment. Works with all data types — primitives, Strings, and object references.
2

Naming Convention

Constants use UPPER_SNAKE_CASE by convention (e.g., MAX_SPEED, TAX_RATE). This makes them visually distinct from regular variables.
3

static final Combo

Class-level constants are typically declared static final, meaning one shared copy exists across all instances of the class.
4

Compile-Time Safety

The compiler enforces final. If you try to reassign a final variable, your code will not compile — the error is caught before the program ever runs.
5

Immutable vs. final

final stops reassignment of the reference, but does not prevent changes to an object's internal state. A final ArrayList can still have items added to it.
✦

KEY TAKEAWAY

Think of a final variable like writing in permanent marker on a whiteboard label. Once you write the name, you can't erase and rewrite it. The label is locked. However, if the label points to a box (an object), you can still change what's inside the box — you just can't redirect the label to a different box.

SECTION 3

Visual Explanation

final Keyword — Primitive vs. Object ReferencePrimitive ConstantObject Reference Constantfinal int MAX = 100;100stored directlyMAX = 200; // ERROR!✗ Compile-time errorCannot reassign a final variablefinal int[] SCORES = {90, 85};refArray object[90, 85]SCORES = new int[3]; //ERR✗ Cannot reassign referenceSCORES[0] = 95; // OK!✓ Contents can still changefinal locks the reference, not the object
On the left, a final primitive stores its value directly — reassignment is completely blocked. On the right, a final object reference locks the arrow (the reference) to the object, but the contents of the object can still be modified. This is the most common source of confusion with final.

The diagram above illustrates the most important distinction you need to remember. When you declare final int MAX = 100, the value 100 is stored directly in that variable and can never be changed. But when you declare final int[] SCORES = {90, 85}, the variable holds a reference (like an address) pointing to the array object in memory. The final keyword locks that reference so you cannot point it at a new array, but you can still modify the elements inside the existing array.

SECTION 4

How final Works Under the Hood

Declaration Syntax Patterns

Java provides several patterns for using final, and each has a specific purpose. The most common pattern for class-level constants combines static with final. The static modifier means the variable belongs to the class itself rather than to any individual object, and final means it cannot be reassigned. Together, they create a single, shared, unchangeable value.

CLASS-LEVEL CONSTANT

publicstaticfinaldoublePI=3.14159265;public static final double PI = 3.14159265;

public = accessible everywhere; static = belongs to the class; final = cannot be reassigned; double = data type; PI = UPPER_SNAKE_CASE name

LOCAL FINAL VARIABLE

finalStringgreeting="Hello";final String greeting = "Hello";

A final variable declared inside a method. It does not need static because it only exists within that method's scope. Useful when a value should not change during a calculation.

BLANK FINAL (INSTANCE CONSTANT)

finalintid;//assignedinconstructorfinal int id; // assigned in constructor

A blank final is declared without an initial value. It must be assigned exactly once — inside every constructor. Each object gets its own immutable id.

⚠

Common Mistake

Students often forget that final does not mean immutable. A final ArrayList<String> still allows you to call .add(), .remove(), and .clear(). The variable cannot point to a different list, but the list's contents are fully mutable.

SECTION 5

When and Where to Use final Constants

Knowing the syntax is only half the battle — you also need to know when to reach for final. Using it in the right places makes your code self-documenting and safer. Overusing it can clutter your code without adding real value. The following diagram categorizes the most common scenarios.

Decision Guide — Should You Use final?Is the value a true constant?YESNOUse static finale.g., MAX_USERS, TAX_RATESet once per object lifetime?YESNOUse blank final fieldassigned in constructorTemporary calculation?YESNOUse local final variablefinal double result = a + b;Do not use finalVariable needs reassignmentQuick Reference — Common Java ConstantsMath.PI Integer.MAX_VALUE Color.RED Collections.EMPTY_LISTAll of these are declared as public static final in the Java standard library.
This decision flowchart helps you determine which type of final declaration to use. Start at the top and follow the yes/no branches. True program-wide constants use static final; per-object constants use blank finals in constructors; temporary values in methods use local finals.
  • ✓ Mathematical or physical constants — values like π, the speed of light, or conversion factors that never change.
  • ✓ Configuration values — maximum retries, default port numbers, or buffer sizes defined at compile time.
  • ✓ Replacing "magic numbers" — the number 7 scattered through your code is mysterious, but DAYS_IN_WEEK tells the reader exactly what it means.
  • ✓ Method parameters you must not change — marking a parameter as final signals to anyone reading the method that the original value is preserved.

SECTION 6

Worked Example

Let's build a small class that calculates the area and circumference of a circle. We'll use final constants to make the code clear, safe, and self-documenting.

Circle Calculator with final Constants

  1. 1

    Step 1 — Identify the Constant

    The value of π (pi) never changes, so it is a perfect candidate for a static final constant. We declare it at the class level using UPPER_SNAKE_CASE.
    public static final double PI = 3.14159265;
  2. 2

    Step 2 — Identify the Instance Constant

    Each circle has a radius that is set when the object is created and should not change afterward. We use a blank final field and assign it in the constructor.
    private final double radius;
  3. 3

    Step 3 — Write the Constructor

    The constructor receives the radius and assigns it to the blank final field. After the constructor finishes, this value is locked for the life of the object.
    public Circle(double radius) { this.radius = radius; }
  4. 4

    Step 4 — Use Constants in Calculations

    The area method uses both constants. Notice that PI is referenced by its name instead of a "magic number" like 3.14. The local variable area could also be declared final since we compute it once and return it.
    public double getArea() { final double area = PI * radius * radius; return area; }
  5. 5

    Step 5 — Complete Class

    Putting it all together, we have a class with one class-level constant (PI), one instance constant (radius), and a local final (area). If anyone tries to reassign any of these, the compiler will immediately produce an error.
    Three levels of final: class constant, instance constant, and local constant — all enforced at compile time.

SECTION 7

Strengths, Limitations & Common Pitfalls

AspectStrength ✓Limitation / Pitfall ✗
ReadabilityUPPER_SNAKE_CASE names instantly tell readers a value won't change.Overusing final on every local variable can add visual clutter without meaningful benefit.
SafetyPrevents accidental reassignment — bugs caught at compile time, not at runtime.Does NOT make objects immutable. A final list can still be cleared or modified.
PerformanceThe compiler can inline static final primitives, slightly improving speed.Performance gains are tiny — don't use final purely for speed.
Thread Safetyfinal fields are safely published in multi-threaded programs (the JVM guarantees visibility).Only the reference is thread-safe. The object itself may still need synchronization.
FlexibilityBlank finals allow per-object constants set at construction time.Once assigned, a final field cannot be changed even if a valid reason arises later in the design.

Strengths and limitations of using final in Java

✦

KEY TAKEAWAY

Use final like you'd use a lock on a door: lock the doors that should stay shut (true constants, critical references), but don't bother locking a closet you open ten times a day. The goal is clarity and safety, not maximum restriction.

SECTION 8

Connection to Advanced Concepts

The final keyword is part of a larger Java ecosystem for controlling change. As you advance, you'll encounter related concepts like final methods (which prevent subclasses from overriding a method), final classes (which prevent inheritance entirely), and immutable objects (where not just the reference but all internal state is unchangeable). Understanding final constants is the first step toward designing robust, predictable software.

FeatureWhat It LocksLevel You'll Learn It
final variableThe reference or primitive value — cannot be reassignedThis lesson ✓
final methodSubclasses cannot override this methodInheritance & Polymorphism
final classNo class can extend (inherit from) this classInheritance & Polymorphism
Immutable object (e.g., String)All internal state — no method can modify the object after creationObject-Oriented Design
enumA fixed set of named constants with type safetyEnums & Advanced Types
record (Java 16+)All fields are implicitly final — data carrier with built-in immutabilityModern Java Features

How final variables relate to other Java features that restrict change

As you move into AP Computer Science or college-level Java courses, you'll see that the philosophy behind final — restrict what can change, and make intentions explicit — is a core principle of good software design. Entire programming paradigms, like functional programming, are built around the idea that data should not mutate. Mastering final constants now gives you a strong foundation for those concepts later.

SECTION 9

Practice Problems

Question 1: CONCEPTUAL

What is the difference between a variable declared as final int x = 5; and one declared as int x = 5;? What happens if you later write x = 10; in each case?
Show answer
Both variables start with the value 5. However, the final version cannot be reassigned. If you write x = 10; for the final variable, the compiler will produce an error saying "cannot assign a value to final variable x." For the non-final version, the reassignment works without any issue. The final keyword acts as a compile-time guard that prevents any code from changing the value after its initial assignment.

Question 2: BASIC CALCULATION

Consider the following code. Will it compile? If not, identify the line(s) that cause errors and explain why. public static final int MAX_SCORE = 100; public static final double PASS_RATE = 0.6; int passingScore = (int)(MAX_SCORE * PASS_RATE); MAX_SCORE = 200;
Show answer
The code will not compile. The first three lines are perfectly valid: MAX_SCORE and PASS_RATE are declared as static final constants, and passingScore correctly computes 100 × 0.6 = 60. The error occurs on the last line, MAX_SCORE = 200;, because MAX_SCORE is final and cannot be reassigned. The compiler catches this before the program runs.

Question 3: INTERMEDIATE

A student writes the following code and expects it to create a truly unchangeable list. Explain why this approach does not fully protect the data, and suggest how to fix it. public static final ArrayList<String> COLORS = new ArrayList<>(); Then somewhere else: COLORS.add("red");
Show answer
The final keyword prevents COLORS from being reassigned to a different ArrayList, but it does not prevent modifications to the list's contents. Calling COLORS.add("red") compiles and runs without error because the reference itself hasn't changed — only the object's internal state has. To make the list truly unmodifiable, you should wrap it: public static final List<String> COLORS = Collections.unmodifiableList(Arrays.asList("red", "blue", "green")); or in Java 9+, use List.of("red", "blue", "green"). This way, both the reference and the contents are protected.

Question 4: APPLIED

You are building a tip calculator for a restaurant app. The sales tax rate is 8.25% and should never change within the program. The tip percentage varies based on user input. Write the class declaration with appropriate use of final and explain your choices for each field.
Show answer
The tax rate should be declared as public static final double TAX_RATE = 0.0825; because it is a true constant — the same for every calculation, never reassigned. The tip percentage should NOT be final because it changes with each user's input: private double tipPercent;. The meal subtotal, passed into a method, could be a final parameter (public double calculate(final double subtotal)) to signal that the method should not alter the original amount. This design uses final where it adds clarity and protection, but avoids it where the variable genuinely needs to change.

Question 5: CRITICAL THINKING

A teammate argues: "We should mark every single variable as final unless it absolutely needs to change." Another teammate says: "Only use final for class-level constants — local finals are unnecessary clutter." Evaluate both positions and state which approach you would recommend and why.
Show answer
Both positions have merit but are somewhat extreme. The first teammate's "final by default" approach maximizes safety: the compiler catches unintended reassignments everywhere. Many professional style guides (like Google's) lean toward this approach. However, marking every loop variable and temporary calculation as final can make code verbose and harder to scan. The second teammate's approach is too loose — local finals are genuinely useful for complex methods where an intermediate result should clearly not change. A balanced recommendation is to always use static final for class-level constants and final for instance fields that should not change after construction. For local variables, use final when it communicates intent (like a computed result that feeds multiple later steps) but skip it for simple, short-lived variables. The guiding principle is readability: if final makes the code's intent clearer, use it.

SUMMARY

Lesson Summary

Summary

The final keyword in Java prevents a variable from being reassigned after its initial value is set. Class-level constants are declared with public static final and named in UPPER_SNAKE_CASE by convention. Blank finals are instance fields assigned once in the constructor, giving each object its own immutable value. Local finals protect intermediate results inside methods.

Remember the critical distinction: final prevents reassignment of the reference, but it does not make objects immutable — a final ArrayList can still have elements added or removed. Use final constants to eliminate magic numbers, improve readability, and catch accidental reassignment at compile time rather than debugging mysterious behavior at runtime.

Varsity Tutors • Java • Final Constants — Use final constants appropriately