static Keyword Usage and Examples

Learn how the Java static keyword works with methods, variables, and blocks. Understand its meaning, purpose, and behavior through clear explanations and real-world examples.

This reference explains static Keyword Usage and Examples through its syntax, examples and boundaries. Use the linked course lessons when the surrounding Java concepts are unfamiliar.

In Java, the static keyword is a modifier used for memory management. It can be applied to variables, methods, blocks, and nested classes. When a member is declared as static, it belongs to the class rather than any specific object of the class. That means you can access it without creating an instance of the class.

Using static allows memory to be allocated only once, at the class loading time. It is especially useful when you want a common property or behavior shared across all instances of a class.

A static variable is shared among all instances of a class. It's also known as a class variable.

class Car {
    static int wheels = 4;  // shared by all cars
    String model;

    Car(String model) {
        this.model = model;
    }

    void display() {
        System.out.println(model + " has " + wheels + " wheels.");
    }
}

public class Test {
    public static void main(String[] args) {
        Car c1 = new Car("Toyota");
        Car c2 = new Car("Honda");

        c1.display();
        c2.display();
    }
}

Toyota has 4 wheels.
Honda has 4 wheels.

Explanation:

Here, the variable wheels is declared as static, meaning it's shared among all Car instances. Changing it from one place affects all objects.

Static methods belong to the class rather than an instance. They can be called without creating an object.

class MathUtils {
    static int square(int x) {
        return x * x;
    }
}

public class Test {
    public static void main(String[] args) {
        int result = MathUtils.square(5);
        System.out.println("Square is: " + result);
    }
}

Square is: 25

Note:

• Static methods cannot access instance variables directly.
• They can only call other static methods or access static variables.

A static block is executed only once when the class is loaded into memory. It’s used to initialize static variables.

class Config {
    static int threshold;

    static {
        System.out.println("Static block called.");
        threshold = 10;
    }
}

public class Test {
    public static void main(String[] args) {
        System.out.println("Threshold: " + Config.threshold);
    }
}

Static block called.
Threshold: 10

Explanation:

The static block runs before anything else in the class, even before main(), if the class is loaded first. It’s perfect for initializing configuration or constant values.

A static class in Java must be a nested class. It cannot access instance members of the outer class directly.

class Outer {
    static int data = 100;

    static class Inner {
        void show() {
            System.out.println("Data: " + data);
        }
    }
}

public class Test {
    public static void main(String[] args) {
        Outer.Inner obj = new Outer.Inner();
        obj.show();
    }
}

Data: 100

Why Use Static Nested Class?

When the nested class doesn't require a reference to the outer class, making it static saves memory and makes your design cleaner.

• Utility classes (e.g., Math, Collections) use static methods extensively.
• Shared constants are defined using static final.
• Factory methods are often static.

Always remember: static members belong to the class, not to objects.

Check the example’s types, inputs and documented behavior before copying it into an application. Some APIs require external libraries, files or platform services; consult their setup notes.

Related explanations: Java Data Types - Primitive and Non-Primitive, Java Class - Blueprint of Objects, Exceptions in Java Introduction.

Supporting documentation: Official Java learning guide.