When to use static methods

Question

I am wondering when to use static methods? Say if I have a class with a few getters and setters, a method or two, and I want those methods only to be invokable on an instance object of the class. Does this mean I should use a static method?

Example:

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

...or:

Obj.someMethod(); // Is this the static way?

I'm rather confused!

Answer 1

One rule-of-thumb: ask yourself "Does it make sense to call this method, even if no object has been constructed yet?" If so, it should definitely be static.

So in a class Car you might have a method:

double convertMpgToKpl(double mpg)

...which would be static, because one might want to know what 35mpg converts to, even if nobody has ever built a Car. But this method (which sets the efficiency of one particular Car):

void setMileage(double mpg)

...can't be static since it's inconceivable to call the method before any Car has been constructed.

(By the way, the converse isn't always true: you might sometimes have a method which involves two Car objects, and still want it to be static. E.g.:

Car theMoreEfficientOf(Car c1, Car c2)

Although this could be converted to a non-static version, some would argue that since there isn't a "privileged" choice of which Car is more important, you shouldn't force a caller to choose one Car as the object you'll invoke the method on. This situation accounts for a fairly small fraction of all static methods, though.

Answer 2

Java main() method is always static, so that compiler can call it without the creation of an object or before the creation of an object of the class.

• In any Java program, the main() method is the starting point from where compiler starts program execution. So, the compiler needs to call the main() method.
• If the main() is allowed to be non-static, then while calling the main() method JVM has to instantiate its class.
• While instantiating it has to call the constructor of that class, There will be ambiguity if the constructor of that class takes an argument.
• Static method of a class can be called by using the class name only without creating an object of a class.
• The main() method in Java must be declared public, static and void. If any of these are missing, the Java program will compile but a runtime error will be thrown.

  Example

  class Book {
     public static void getBookInfo() { //static method
        System.out.println("Welcome to Edureka");
     }
  }
  public class Test {
     public static void main(String[] args) {
        //Call static method of Book class using class name only
        Book.getBookInfo();
     }
  }

  Output

  Welcome to Edureka