When to Use Static Methods in Java

By the end of this page, you will understand the difference between instance methods and static methods in Java, when each should be used, how method calls like obj.method() and Class.method() differ, and the common rules developers follow in real code.

In Java, a method can belong to either:

• an instance of a class, or
• the class itself.

An instance method works with a specific object. You call it on an object:

Obj x = new Obj();
x.someMethod();

A static method belongs to the class, not to any one object. You call it on the class name:

Obj.someMethod();

The key question is this:

Does the method need data from a specific object?

• If yes, make it an instance method.
• If no, and it performs work that does not depend on object state, it can be a static method.

Why this matters

This distinction is important because it affects how your program is designed.

• Instance methods model behavior of real objects.
• Static methods model behavior that is shared, global, or independent of any object.

Example

public class BankAccount {
    private double balance;

       {
        balance += amount;
    }

       {
         balance;
    }
}

Think of a class as a blueprint for houses, and an object as one actual house built from that blueprint.

• An instance method is something you do with one specific house, like paintWall() or openDoor().
• A static method is something related to the blueprint itself, or a general utility, like calculateBuildingCost().

Another way to think about it:

• Instance method = needs a specific object
• Static method = does not need a specific object

So if a method needs to know the values inside x, call it like this:

x.someMethod();

If it does not care about any particular object, it may be static:

Obj.someMethod();

Instance method syntax

public class Person {
    private String name;

    public Person(String name) {
        this.name = name;
    }

    public String getName() {
        return name;
    }
}

Usage:

Person p = new Person("Ava");
System.out.println(p.getName());

getName() is an instance method because it returns data from a particular Person object.

Static method syntax

public class StringUtils {
    public static boolean isEmpty(String value) {
        return value == null || value.isEmpty();
    }
}

Consider this code:

public class Counter {
    private int count = 0;

    public void increment() {
        count++;
    }

    public static void sayHello() {
        System.out.println("Hello");
    }
}

public class Main {
    public static void main(String[] args) {
        Counter c = new Counter();
        c.increment();
        Counter.sayHello();
    }
}

Step by step

1. Counter c = new Counter();

   • A new Counter object is created.
   • Its count field starts at 0.

Static methods are useful when behavior does not belong to one specific object.

Common uses for static methods

Utility/helper methods

Integer.parseInt("42");
Math.max(5, 9);

These methods perform work without needing an instance.

Factory methods

Sometimes a class provides a static method to create objects:

LocalDate today = LocalDate.now();

now() is static because it creates or returns a value without needing an existing LocalDate object.

Shared constants or class-level behavior

A method may work with data shared by the whole class rather than one object.

Common uses for instance methods

Working with object state

cart.addItem(product);
user.changePassword("newPass");
account.withdraw(100);

These actions affect one particular object.

Getters and setters

user.getEmail();
user.setEmail();

In real Java codebases, developers usually choose between static and instance methods based on whether the method depends on object state.

Typical patterns

1. Instance methods for domain objects

Classes like User, Order, Cart, and BankAccount usually have instance methods because each object has its own data.

order.calculateTotal();
user.getDisplayName();
cart.clear();

2. Static methods for stateless helpers

Utility classes often contain only static methods.

public class PriceUtils {
    public static double applyDiscount(double price, double percent) {
        return price - (price * percent / 100.0);
    }
}

3. Static factory methods

Instead of using constructors directly, a class may offer named static methods:

public class User {
     String name;

      {
        .name = name;
    }

      User  {
          ();
    }
}

1. Making a method static just because you want to call it easily

Beginners sometimes make methods static to avoid creating an object.

Broken design:

public class User {
    private String name;

    public static String getName() {
        return name; // error
    }
}

Problem:

• name belongs to each User object.
• A static method has no specific User object to read from.

Fix:

public class User {
    private String name;

    public String getName() {
        return name;
    }
}

2. Trying to access instance fields from a static method

Broken code:

public class Example {
        ;

        {
        System.out.println(value); 
    }
}

Static method vs instance method

public class  {
      value;

       {
        .value = value;
    }

        {
         x * ;
    }
}

// Instance method
class User {
    private String name;

    public String getName() {
        return name;
    }
}

User u = new User();
u.getName();

// Static method
class MathHelper {
    public static int square(int x) {
        return x * x;
    }
}

MathHelper.square(4);

Quick rules

• Use an instance method if the method needs object data.
• Use a static method if the method does not depend on object data.
• Getters and setters are usually instance methods.
• Static methods are called with ClassName.method().
• Instance methods are called with object.method().
• Static methods cannot directly use:
  • instance fields
  • instance methods
  • this

Easy test

Ask:

Should getters and setters be static in Java?

Usually no. Getters and setters normally work with fields stored in a specific object, so they should be instance methods.

When should I make a method static?

Make a method static when it does not depend on instance fields or instance behavior. Utility and helper methods are common examples.

Can a static method access instance variables?

Not directly. A static method does not run on a specific object, so it cannot directly use instance variables.

Can an instance method call a static method?

Yes. Instance methods can call static methods in the same class directly, or through the class name.

Can a static method create objects?

Yes. Static methods often create and return objects, such as factory methods.

Is ClassName.method() always static?

Yes, that syntax is used for static methods. If a method is not static, you should call it on an object.

Are static methods object-oriented?

They can be useful in object-oriented programs, but they are not tied to object state. If behavior belongs to an object, instance methods are usually a better fit.

• Classes and objects — Static and instance methods make sense only when you understand the difference between a class and an object.
• Instance variables — Instance methods often read or modify instance fields.
• Static variables — These are shared across all objects and are closely related to static methods.
• Constructors — Constructors create objects, which are needed before calling instance methods.
• this keyword — this is available in instance methods and helps refer to the current object.
• Encapsulation — Getters, setters, and instance methods are part of hiding and controlling object state.
• Object-oriented programming — Choosing between static and instance methods is a core design decision in OOP.