Static Methods in Java: Class-Level Behavior and Usage

The class name is the receiver. No object is created and none is needed.

public class MathUtils {
    public static int square(int value) {
        return value * value;
    } public static void main(String[] args) {
        // Called through the class name
        int result = MathUtils.square(SIX);
        System.out.println(result);
    }
}

Because there is no object, there is also no way to reach one. Attempting to use this inside a static method is a compile error, and so is touching an instance field.

Both keywords answer a question about which object, and a static method has no object to point at. The compiler rejects the attempt rather than passing some default, because any guess would be wrong.

public class Report {
    private String owner;
    // NOT ALLOWED: no object exists in a static method
    // public void send() {
    //     System.out.println(owner);     // cannot read an instance field
    //     this.owner = "x";              // no this reference exists
    //     helper();                      // helper must be static too
    // }
}

The way out is to pass the object in as a parameter, which converts the problem back into an ordinary instance method. If a method needs object state, it should just be an instance method.

Every instance field has its own copy per object. A static field has exactly one copy on the class, shared by everything that uses it.

public class Counter {
    private static int totalCreated = 0;
    // one copy, on the class
    private int instanceCount = 0;
    // a copy per object
    public Counter() {
        totalCreated = totalCreated + 1;
    } public static int getTotalCreated() {
        return totalCreated;
    }
}

Creating five Counter objects leaves totalCreated at five while each object keeps its own instanceCount. This is what makes static state shared mutable state, which is precisely why it needs care under concurrency.

This is the distinction that catches experienced developers too, so it is worth being precise about. An instance method can be overridden, and the runtime type of the object selects the implementation. A static method can only be hidden, and the compiler selects using the declared type of the reference at the point of the call.

public class Base {
    public static void describe() {
        System.out.println("base");
    }
}public class Derived extends Base {
    public static void describe() {
        // legal, this is hiding
        System.out.println("derived");
    }
}public class Main {
    public static void main(String[] args) {
        Base reference = new Derived();
        reference.describe();
        // prints base, not derived
        Derived.describe();
        // prints derived
    }
}

The variable holds a Derived object, yet the call prints base. Dynamic dispatch never happens for static methods because there is no object being dispatched on; the compiler already decided from the reference type. This is exactly the opposite of dynamic method dispatch.

The entry point every Java program starts from is static, for a practical reason: the JVM must be able to launch it before any object of your class exists.

public static void main(String[] args) {
    // args holds the command line values
    System.out.println(args.length);
}

There is nothing to construct the class from, so the class itself is the only thing available to call it on. This is also why you can call a static method from anywhere without an instance, and why a main method in any class in a project can serve as the program entry point.

A class that exists only to hold static helpers should not be instantiable. Marking the constructor private enforces that at compile time, and is what the standard library does for Math and Collections.

public final class StringUtils {
    // Prevent anyone from creating an instance of a utility class
    private StringUtils() {
        throw new UnsupportedOperationException("utility class");
    } public static boolean isBlank(String value) {
        return value == null || value.trim().isEmpty();
    }
}StringUtils.isBlank(null);
// works
// new StringUtils();       // compile error, constructor is private

The final keyword matters as well. A utility class with no reason to be subclassed should be final, which stops a subclass from being created. That also prevents the static hiding problem in the previous section from arising here, since nothing can extend the class. Both practices are covered under the final keyword.

One of the most valuable uses of a static method is a factory, because it gives a call site a meaningful name and lets the method decide which concrete type to return.

public class Money {
    private final long amountInCents;
    private Money(long amountInCents) {
        this.amountInCents = amountInCents;
    } // Named factories, clearer than a bare constructor
    public static Money ofCents(long cents) {
        return new Money(cents);
    } private static final long NO_CENTS = 0L;
    public static Money zero() {
        return new Money(NO_CENTS);
    }
}

Compared with a plain constructor, a factory can return a cached instance, an existing instance, or a subtype. It is also the idiomatic way to hide a private constructor, which is the pattern behind List.of() and the immutable types described in records.

Static is the right choice when the operation is genuinely stateless, when it is a calculation, a parser, a factory, or a constant accessor. The test is simple: would this method give a sensible answer if it had no idea which object called it? If yes, static fits.

Avoid it when the method reads or writes instance state, because you cannot reach that state and forcing it through parameters undoes the object model.

Frequently Asked Questions

What is a static method in Java?

A method that belongs to the class rather than to any object of it. It is invoked through the class name, such as Math.sqrt, and needs no instance to exist. Because there is no particular object involved, it has no this reference and cannot touch instance fields or call instance methods directly.

Can we override a static method in Java?

No. A subclass may declare a static method with the same signature, and the compiler allows it, but this is method hiding rather than overriding. Selection happens at compile time using the declared type of the reference, not the runtime type of the object, so writing @Override on such a method is a compile error.

Why can a static method not use the this keyword?

Because this names a particular object, and a static method has no object to name. It is invoked on the class, so there is nothing for this to refer to. The same reasoning applies to super and to instance fields. If you need object state, pass the object in as a parameter or make the method an instance method.

Can a static method call another non-static method?

Not directly, and trying is a compile error. It may only call static methods and access static fields, since both belong to the class. A common workaround is to pass the needed object in as a parameter, but if the method needs instance state at all it is usually better written as an instance method.

Are static methods inherited?

They are available to subclasses, but they are not inherited in the sense that matters. A subclass can redeclare one to hide it, and the compiler then picks using the declared type of the reference at the call site. Unlike an overridden instance method, no runtime type check or dynamic dispatch is involved.

Why should a utility class have a private constructor?

To make instantiation impossible at compile time, which signals that the class is meant to be used through its static methods alone. Making the class final as well prevents subclassing, which would otherwise allow a subclass to hide the static methods and reintroduce the surprising selection behaviour described earlier.

What is a static factory method and why use one?

A static method that creates and returns an instance. It is more readable than a bare constructor at the call site, it can hide a private constructor, it can return a cached instance to avoid repeated allocation, and it is free to return a subtype of the declared class.

Can a static method be used to store state?

It can, but you should think carefully first. A static field is shared by every instance and by every thread, so mutating it is a concurrency hazard, since a simple increment is not atomic. Shared immutable constants are fine, and an atomic wrapper or a lock makes shared counters safe, but per-object state has no business in a static field.