Understanding “static” in “public static void main” in Java

Following points explain what is “static” in the main() method: 

• main() method: The main() method, in Java, is the entry point for the JVM(Java Virtual Machine) into the java program. JVM launches the java program by invoking the main() method. 
  

• Static is a keyword. The role of adding static before any entity is to make that entity a class entity. It means that adding static before methods and variables make them class methods and class variables respectively, instead of instance methods and instance variables. 
  Hence, static methods and variables can be directly accessed with the help of Class, which means that there is no need to create objects in order to access static methods or variables. 
  

// Making a function as static
static void func()
{}

// Making a variable as static
static int var;

• Static methods: When a method is declared with static keyword, it is known as static method. As discussed above, any static member can be accessed before any objects of its class are created, and without reference to any object. 
  

// Making a static function
class GfG
{
    static void func()
    {}
}

// Calling a static function
GfG.func();

• Static main() method: When the static keyword is added in the function definition of main() method, then it is known as static main() method. 
  

class GfG
{
    // Making a static main function
    public static void main(String[] args)
    {}
}

Need of static in main() method: Since main() method is the entry point of any Java application, hence making the main() method as static is mandatory due to following reasons: 

• The static main() method makes it very clear for the JVM to call it for launching the Java Application. Otherwise, it would be required to specify the entry function for each Java application build, for the JVM to launch the application.
• The method is static because otherwise there would be ambiguity which constructor should be called. 
  Example, if the class looks like this: 
  

public class GfG{
  protected GfG(int g){}
  public void main(String[] args){
  }
}

• The JVM now enters an ambiguity state deciding whether it should call new GfG(int)? If yes, then what should it pass for g? If not, then should the JVM instantiate GfG without executing any constructor method? 
  There are just too many edge cases and ambiguities like this for it to make sense for the JVM to have to instantiate a class before the entry point is called. That’s why main is static.
• The main() method is static because its convenient for the JDK. Consider a scenario where it’s not mandatory to make main() method static. Then in this case, that just makes it harder on various IDEs to auto-detect the ‘launchable’ classes in a project. Hence making it a convention to make the entry method ‘main()’ as ‘public static void main(String[] args)’ is convenient.

What if we don’t write “static” before the main method: If we do not write “static” before the main method then, our program will be compiled without any compilation error(s). But at the time of execution, the JVM searches for the main method which is public, static, with a return type and a String array as an argument. If such a method is not found then an error is generated at the run time.

Java

/*package whatever //do not write package name here */

import java.io.*;

class GFG {
    public void main (String[] args) {
        System.out.println("GFG!");
    }
}

Output: An error message will be shown as follows