Search⌘ K
AI Features
Home
Courses
Modern Java: From Fundamentals to Advanced Architecture

Static Members and Constants

Explore the use of static members and constants in Java to manage shared data across objects. Understand how static fields differ from instance variables, how to create utility methods with static, and how to define immutable constants using static final. Gain insights into best practices for accessing static members and improving your Java code's organization and efficiency.

We'll cover the following...

We reach a natural turning point in our object-modeling skills. Until now, every field and method we have written has belonged to a specific object. If we create ten objects, we have ten separate copies of their instance variables. However, sometimes we need data that is shared across all instances of a class, or methods that perform tasks without needing an object at all.

To handle these scenarios, Java provides the static keyword. Understanding static members is essential for efficient memory management, creating utility libraries, and defining global constants that make our code safer and easier to read.

Static fields and shared state

In Java, a variable declared with the static keyword is called a static field or class variable. Unlike instance variables, which are unique to each object, a static variable has only one copy in memory, regardless of how many objects we create. This single copy is shared among all instances of the class.

If one object modifies a static field, that change is immediately visible to all other objects. This is useful for maintaining shared state, such as counting how many objects of a class have been created or managing a shared resource configuration.

In this example, we track the number of User objects created using a static field. We also demonstrate that static data can be accessed in two ways: by class name or by an object instance.

Java 25
class User {
    String name;              // Instance variable (unique per object)
    static int userCount = 0; // Static variable (shared by all objects)
    User(String name) {
        this.name = name;
        userCount++; // Increment the shared count
    }
}
public class Main {
    public static void main(String[] args) {
        User u1 = new User("Alice");
        User u2 = new User("Bob");
        User u3 = new User("Charlie");
        // Accessing the static variable using the Class Name
        System.out.println("Total users: " + User.userCount);
        
        // Accessing instance variables
        System.out.println("User 1: " + u1.name);
        
        // Accessing the static variable using the object
        System.out.println("Total users from user 2: " + u2.userCount);
    }
}

  • Line 3: We declare userCount as static. It belongs to the User class, not any individual user.

  • Line 7: Inside the constructor, we increment userCount. Every time new User() is called, this shared variable increases.

  • Line 18: We access userCount using the class name User.userCount. This is the preferred way to access static members because it makes it clear the data belongs to the class.

  • Line 24: We access the same static variable using the object reference u2.userCount. Even though we use u2, Java looks up the static field for the User class. Both lines 18 and 24 print 3.

Note: While accessing static variables via an object (like u2.userCount) is valid Java syntax, it can be misleading. A reader might think userCount is specific to u2. It is standard practice to use the class name (User.userCount) to avoid confusion.

Static methods and utilities

A static method is a method that belongs to the class rather than an instance. Because it is not attached to a specific object, it cannot use the this keyword, nor can it directly access instance variables.

We typically use static methods for utility functions, which perform a calculation or action based solely on their input parameters and do not depend on the state of any specific object. The main method is static because the JVM needs to invoke it before any objects are instantiated.

A classic real-world example is Java’s built-in Math class. We never create an object of Math (e.g., new Math()). Instead, we call its methods directly to perform calculations. We can write our own utility classes to group similar helper methods.

Here, we define a GameHub class with a static method to roll a die. Note how our static method calls Java’s Math.random(), which is itself a static method.

Java 25
class GameHub {
    // Utility method: operates independently of any object state
    static int rollDice() {
        // Math.random() is a built-in static method
        // We call it directly using the class name 'Math'
        double randomValue = Math.random(); 
        
        // Convert 0.0-0.99... to 1-6
        return (int) (randomValue * 6) + 1;
    }
}
public class Main {
    public static void main(String[] args) {
        // Call the static method using the Class Name
        int result = GameHub.rollDice();
        
        System.out.println("You rolled a: " + result);
    }
}

  • Line 4: We define rollDice as static. It does not rely on any instance variables like playerName or score.

  • Line 7: We call Math.random(). Notice we do not say new Math().random(). We access the functionality directly through the class name.

  • Line 16: In main, we call our own utility method using GameHub.rollDice(). No new keyword is required to use this logic.

Constants in Java

We often use the static keyword in combination with final to create constants. A constant is a value that is shared globally (static) and cannot be changed once assigned (final).

The final keyword in Java acts as a lock: it ensures that once a variable is assigned a value, it cannot be changed (reassigned). When we combine static (shared by all) and final (unchangeable), we get a global constant.

In Java, the naming convention for constants is UPPER_SNAKE_CASE. Using constants replaces “magic numbers” (raw numbers scattered in code) with meaningful names, improving readability and maintainability.

Java 25
class PhysicsConstants {
    // public: accessible everywhere
    // static: belongs to the class
    // final: cannot be changed
    public static final double GRAVITY = 9.80665;
    public static final double SPEED_OF_LIGHT = 299_792_458;
}
public class Main {
    public static void main(String[] args) {
        double mass = 70.0; // kg
        
        // Using the constant makes the formula self-explanatory
        double weight = mass * PhysicsConstants.GRAVITY;
        
        System.out.println("Weight: " + weight + " Newtons");
        
        // ERROR: Cannot reassign a final variable
        // PhysicsConstants.GRAVITY = 10.0; 
    }
}

  • Line 5: We declare GRAVITY as public static final.

    • public: Other classes can access it.

    • static: There is only one copy in memory.

    • final: The value is locked and cannot be changed.

  • Line 19: If we try to assign a new value to GRAVITY, the compiler will throw an error, ensuring our constant remains constant.

Access rules and best practices

Java enforces strict rules regarding how static and instance members interact. Understanding these rules prevents common compilation errors.

  1. Static methods cannot access instance members directly: Since a static method runs without an object, it has no this reference. It cannot read an instance field like name or call an instance method like getName() because it doesn’t know which object’s data to use.

  2. Instance methods can access static members: An object always knows its class, so an instance method can freely read or modify static fields.

Best practice: Always access static members through the class name (User.userCount), not an object reference (u1.userCount). While Java allows access via objects, this is misleading because it makes it seem as if the field belongs to that specific object, when it actually belongs to the whole class.

Java 25
class Validator {
    static int minAge = 18; // Static context
    String validationMessage = "Valid"; // Instance context
    static boolean check(int age) {
        // ERROR: Cannot access instance variable 'validationMessage' from here
        // System.out.println(validationMessage); 
        
        return age >= minAge; // OK: Accessing static from static
    }
    
    void updateMessage() {
        // OK: Instance method accessing static field
        if (minAge > 21) { 
            validationMessage = "Strict Validation";
        }
    }
}

  • Line 5: The check method is static. It cannot see validationMessage because that string only exists inside a specific Validator object.

  • Line 9: It can, however, see minAge because both are static.

  • Line 13: The instance method updateMessage can see both instance variables and static variables.

We have now separated data that belongs to an individual object from data that belongs to the class as a whole. By using static, we can create efficient shared resources, build powerful utility libraries, and define readable global constants using final. These tools allow us to write code that is not only functional but also organized and memory-efficient.