Java static Keyword
Usage and Examples

static Keyword in Java

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.

Why Use static?

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.

1. Static Variables

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.

2. Static Methods

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.

3. Static Blocks

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.

4. Static Classes (Nested Static Class)

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.

Common Use Cases of static

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

Final Thoughts

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