What Does static Mean in Java?

Static means belongs to the class rather than to an instance. Everything declared static has exactly one copy per class, shared by every instance and reachable without creating an object.

A static field is a class-level variable. It is created when the class is initialised and lives until the class is unloaded, so it is the natural place for counters, configuration, caches and constants. A static method is a class-level operation with no this reference, which means it cannot touch instance state directly. A static nested class is a class defined inside another class, held by the outer class rather than by an instance; it can still be instantiated on its own, but it does not get an implicit reference to an enclosing instance the way a non-static inner class does. A static initializer block runs once, when the class is initialised, and is the traditional place for expensive one-time setup.

Two rules make the design consequences concrete. A static method cannot reference an instance field or call an instance method of the same class, because there is no instance to read them from. And a static method can be called without an object, which means it cannot be overridden polymorphically — a subclass method with the same signature hides it instead.

The classic smell is a static method that reaches for global state. Once a class has static mutable fields, two threads can corrupt each other's state, and the class becomes untestable without resetting that state between cases. Static constants are fine; static mutable state is usually a design smell.

There are three hard restrictions, and each produces a specific compile error you should be able to recognise on sight.

First, a static method cannot reference an instance field or call an instance method of its own class. The error reads that a non-static variable cannot be referenced from a static context, and the reason is that the method has no this and therefore no object to read the state from. The same restriction applies in the other direction for static nested classes, which have no enclosing instance.

Second, an inner (non-static) class cannot declare a static member other than a constant. Modern Java relaxed this so that inner classes may declare static members, but the classic restriction is still worth naming because it explains why nested helper classes are so often declared static.

Third, you cannot reference a static member through an instance in a way that reads oddly. instance.staticField compiles, with a warning, but it is confusing because it suggests the field belongs to that object.

public class Main {
    static int counter = 0;
    static final int MAX = 100;

    public static void main(String[] args) {
        Counter c = new Counter();
        System.out.println("instances now  : " + Counter.instances);
        c.touch();
        System.out.println("after touch    : " + Counter.instances);
        System.out.println("static final   : " + Counter.MAX);

        // A static method cannot read instance state.
        // static void broken() { System.out.println(instances); }
    }
}

class Counter {
    static int instances = 0;
    static final int MAX = 100;

    void touch() {
        instances++;
    }
}

The output makes the shared-state point directly: two different objects contribute to the same static counter, because there is only one counter per class, not one per instance. That is exactly what makes static useful for a registry of live objects and dangerous for anything a caller might expect to be isolated.