Static Keyword

Static Variables

A static variable (also called a class variable) is allocated once, in a single shared memory location, regardless of how many objects of the class are created. Changing it through any one object is visible through every other object and through the class name directly, because they all refer to the same memory. Static variables are commonly used for values that logically belong to the whole class, such as a running counter of how many objects have been created.

Static Methods

A static method belongs to the class and can be called without creating an object, using ClassName.methodName(). Because a static method has no associated object (no implicit this), it can only directly access other static members — it cannot directly reference instance variables or call instance methods without first obtaining an object reference. This is why main is declared static: the JVM must be able to call it before any object of the class exists.

Static Blocks and Initialization Order

A static block is a section of code wrapped in static { ... } that runs exactly once, when the class is first loaded into the JVM — before any object of that class is created and before the main method runs, if the static block is in the class containing main. Static blocks are used to perform one-time setup for static data that is too complex for a simple inline initializer. If a class has multiple static variables and static blocks, they execute in the exact top-to-bottom order they appear in the source file.

• Static members are loaded once per class, not once per object.
• Static methods cannot use this or super, since there is no object context.
• Static blocks run once, at class-loading time, before any constructor or instance code.

Static vs Instance: Shared State vs Per-Object State

An instance variable gets a fresh copy inside every object, so two objects can hold different values. A static variable has exactly one copy for the whole class, so every object reads and writes the same value. Choose by asking whose data it is: a customer's name belongs to each customer object, while the total number of customers belongs to the class. Constructors usually work on instance state, but they can also update static state, as the counter example shows.

Call Static Members Through the Class Name

Java lets you write object.staticMethod(), but the object is ignored: the compiler decides which method to call from the variable's declared type, and it even works when the variable is null. Because this hides the fact that the member is shared, the compiler warns about it (javac -Xlint:static), and most style guides forbid it. Always write ClassName.member, as in Math.max(a, b) or Counter.getCount().

Constants with static final

Combining static with final creates a class-level constant: one shared value that can never change, such as Math.PI or Integer.MAX_VALUE. By convention constants are named in UPPER_SNAKE_CASE. A class made only of constants and static helper methods (a utility class, like java.lang.Math) usually also has a private constructor, so nobody creates pointless objects of it.

Static Methods Are Hidden, Not Overridden

A subclass can declare a static method with the same signature as one in its parent, but this hides the parent's method rather than overriding it. Overriding is decided at runtime by the actual object; hiding is decided at compile time by the declared type of the variable. So with Animal pet = new Dog(), pet.sound() runs Dog's instance method, while the static kind() still runs Animal's version.

Static Nested Classes

A class declared static inside another class is a static nested class. Unlike an inner class, it does not hold a reference to an outer object, so you can create it with new Outer.Nested() without any Outer instance. It is commonly used for helper types that only make sense alongside the outer class, such as a Builder or a Node in a linked list.

When to Use static, and When Not To

Static fits things that truly belong to the class rather than to any object:

• Good uses: constants, stateless helper methods (Math.abs, Integer.parseInt), static factory methods (List.of(...)), and the main entry point.
• Use with care: mutable static fields are global state shared by the whole program. They make code harder to test and are unsafe when several threads change them at once.
• Avoid: making methods static just to skip creating an object. If a method needs an object's data, it should be an instance method.

Examples

public class Counter {
    static int objectCount;

    static {
        System.out.println("Static block: class Counter is being loaded");
        objectCount = 0;
    }

    Counter() {
        objectCount++;
    }

    static int getCount() {
        return objectCount;
    }

    public static void main(String[] args) {
        new Counter();
        new Counter();
        new Counter();
        System.out.println("Objects created: " + Counter.getCount());
    }
}

Static block: class Counter is being loaded
Objects created: 3

class Visitor {
    static int totalVisitors; // one copy, shared by the whole class
    int visits;               // one copy per object

    void visit() {
        totalVisitors++;
        visits++;
    }
}

public class SharedVsOwn {
    public static void main(String[] args) {
        Visitor asha = new Visitor();
        Visitor ravi = new Visitor();

        asha.visit();
        asha.visit();
        ravi.visit();

        System.out.println("Asha visits: " + asha.visits);
        System.out.println("Ravi visits: " + ravi.visits);
        System.out.println("Total visitors: " + Visitor.totalVisitors);
    }
}

Asha visits: 2
Ravi visits: 1
Total visitors: 3

final class Temperature {
    static final double FREEZING_C = 0.0; // a constant: static and final

    private Temperature() { } // utility class: no objects needed

    static double toFahrenheit(double celsius) {
        return celsius * 9 / 5 + 32;
    }
}

public class TemperatureDemo {
    public static void main(String[] args) {
        System.out.println(Temperature.toFahrenheit(Temperature.FREEZING_C));
        System.out.println(Temperature.toFahrenheit(100));
    }
}

32.0
212.0

class Animal {
    static String kind() { return "Animal"; }
    String sound() { return "..."; }
}

class Dog extends Animal {
    static String kind() { return "Dog"; } // hides Animal.kind(), does not override it
    @Override
    String sound() { return "Woof"; }      // overrides Animal.sound()
}

public class HidingDemo {
    public static void main(String[] args) {
        Animal pet = new Dog();
        System.out.println(pet.sound()); // chosen at runtime by the object: Dog
        System.out.println(pet.kind());  // chosen at compile time by the variable type: Animal
    }
}

Woof
Animal

Exercise

Give every Ticket a unique, increasing id. The class should keep a shared counter, and each new ticket takes the next number.

Expected output: 1, 2, 3, each on its own line.

class Ticket {
    // TODO: a static counter shared by all tickets
    // TODO: an instance field for this ticket's id

    Ticket() {
        // TODO: increase the counter and store its value as this ticket's id
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        System.out.println(new Ticket().id);
        System.out.println(new Ticket().id);
        System.out.println(new Ticket().id);
    }
}

class Ticket {
    static int counter = 0;
    int id;

    Ticket() {
        id = ++counter;
    }
}

public class TicketDemo {
    public static void main(String[] args) {
        System.out.println(new Ticket().id); // 1
        System.out.println(new Ticket().id); // 2
        System.out.println(new Ticket().id); // 3
    }
}

Quick quiz

Interview questions