Constants in Java

Introduction

In the previous lesson, you learned about variables — named storage locations whose values can change while a program runs. But some values should never change once they are set: the value of PI, the maximum number of login attempts allowed, or the number of days in a week. Java gives you a way to protect these values from accidental modification: constants.

final double PI = 3.14159;
final int MAX_LOGIN_ATTEMPTS = 3;

What is a Constant?

A constant is a variable whose value is assigned once and cannot be changed afterward. In Java, you create a constant by declaring a variable with the final keyword. Once a final variable has been assigned a value, any attempt to reassign it causes a compile-time error.

Why Constants are Needed

The final Keyword

The final keyword is what turns an ordinary variable into a constant. It can be applied to local variables, instance fields, static fields, method parameters, methods (to prevent overriding), and even classes (to prevent inheritance) — but in this lesson we focus on its use with variables.

final int MAX_SCORE = 100;

MAX_SCORE = 200; // Compile-time error: cannot assign a value to final variable MAX_SCORE

Declaring Constants

A constant is declared by placing final before the type. It is best practice — though not required by the compiler — to also declare number-like constants as static when they belong to a class, since the value is the same for every instance.

public class AppConfig {
    static final int MAX_USERS = 500;
    static final String APP_NAME = "PrograMinds";
    static final double VERSION = 1.0;
}

Naming Conventions

By strong convention, Java constants are named in UPPER_SNAKE_CASE — all uppercase letters with underscores separating words. This immediately signals to anyone reading the code that the value never changes.

Local Constants

A local constant is declared inside a method and must be assigned a value at the point of declaration (or exactly once before it is used).

public void calculateArea() {
    final double PI = 3.14159;
    double radius = 5.0;
    double area = PI * radius * radius;
    System.out.println("Area: " + area);
}

Static Final Class Constants

The most common way to define a constant that belongs to a whole class (rather than one object) is to mark a field both static and final. This is often called a "class constant" — there is exactly one copy shared by every instance, and it never changes.

public class Circle {
    static final double PI = 3.14159;

    double radius;

    Circle(double radius) {
        this.radius = radius;
    }

    double getArea() {
        return PI * radius * radius;
    }
}

Blank Final Variables

A "blank final" is a final variable that is declared without an initial value, on the condition that it is assigned exactly once — for instance fields, this is typically done inside every constructor.

public class Employee {
    final String employeeId; // blank final

    Employee(String employeeId) {
        this.employeeId = employeeId; // assigned exactly once, here
    }
}

Constants in Interfaces

Any field declared inside a Java interface is implicitly public, static, and final, even if you don't write those keywords yourself. This makes interfaces a common (if old-fashioned) place to group related constants.

public interface Constants {
    int MAX_USERS = 500;      // implicitly public static final
    String APP_NAME = "PrograMinds";
}

Constants vs Variables

Real-World Example

Applications commonly centralize their fixed settings into constants so that changing a single value updates behavior everywhere it is used.

public class BankAccount {
    static final double MIN_BALANCE = 500.0;
    static final double OVERDRAFT_FEE = 35.0;

    double balance;

    BankAccount(double balance) {
        this.balance = balance;
    }

    void withdraw(double amount) {
        if (balance - amount < MIN_BALANCE) {
            balance -= OVERDRAFT_FEE;
            System.out.println("Overdraft fee applied!");
        } else {
            balance -= amount;
        }
    }
}

MIN_BALANCE and OVERDRAFT_FEE are business rules that should never change accidentally while the program runs — exactly what final static constants are for.

Common Mistakes

final int MAX = 10;
MAX = 20; // Compile-time error

final String id; // Error if never assigned before use

Best Practices

FAQs

Summary