Valid variants of main() in Java

We know that a Java code begins to execute from the main method. During runtime, if JVM can't find any main method then we will get a runtime exception: 
No such Method Error: 
 

Main method not found in class, please define the main method as:
public static void main(String[] args) 

to avoid this problem there should be the main method. We also know that the java main method has a particular prototype, which looks like: 
 

public static void main(String[] args)

 
Even though the above syntax(prototype) is very strict but some little changes are acceptable. This makes it not so strict that if we perform any change then we will get a runtime exception. We can do several allowed modification to our main method. 
The following Changes are acceptable. 
Let's understand the different variants of main() that are valid.
 

• Default prototype: Below is the most common way to write main() in Java. 

class Test 
{
    public static void main(String[] args)
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

Meaning of the main Syntax: 

public:  JVM can execute the method from anywhere.
static:  Main method can be called without object.
void:    The main method doesn't return anything.
main():  Name configured in the JVM.
String[]: Accepts the command line arguments.
args:- the name of the String array is args.
 

• Order of Modifiers: We can swap positions of static and public in main(). 

//Java code to understand that The Order of Modifiers don't matters
class Test
{
    static public void main(String[] args)
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

• Variants of String array arguments: We can place square brackets at different positions for string parameter. 

class Test
{
    public static void main(String[] args)
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

class Test
{
    public static void main(String []args)
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

class Test
{
    public static void main(String args[])
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

• Args or anything: Instead of args we can write anything which is a valid java identifier. You can write anything here, you can write your name or company's name or anything you want to write but it must follow the rule of being a java identifier. 
  Example: 

class Gfg{

       public static void main(String[] geeksforgeeks){ 
               System.out.println("Instead of args we have written geeksforgeeks");
       }
}

Output: 

Instead of args we have written geeksforgeeks

• Var-args instead of String array: According to the rule whenever there is one dimensional array we can replace the array with var-arg parameter.So here we can change our string array using var-args. (the triple dots instead of []) 
  Example: 

//Java code-> using Var-Args instead of the array
//please note these code may not run in gfg IDE, better run it on other IDEs e.g, eclipse
class Gfg{
    
        final public static void main(String... args){
        System.out.println("Var-args main method");
    }
}

Output: 

Var-args main method

• Final Modifier String argument: We can make String args[] as final. 

class Test
{
    public static void main(final String[] args)
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

• Final main method: We can declare the main method with the final keyword.This cannot change the execution or give any error. 
  Example: 
   

//Java code having the final main method
////please note these code may not run in gfg IDE, better run it on other IDEs e.g, eclipse
class Gfg{
 
    final public static void main(String[] args){
          
        System.out.println("final main method");

        }
}

Output: 

final main method

• synchronized keyword to static main method: We can make main() synchronized. 

//Java code having Synchronized main method
//please note these code may not run in gfg IDE, better run it on other IDEs e.g, eclipse
class Test
{
    public synchronized static void main(String[] args)
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

• strictfp keyword to static main method: strictfp can be used to restrict floating point calculations. 
   

//Java code-> using strictfp modifier in main method
//please note these code may not run in gfg IDE, better run it on other IDEs e.g, eclipse
class Test
{
    public strictfp static void main(String[] args)
    {
        System.out.println("Main Method");
    }
}

Output:

Main Method

• Combinations of all above keyword to static main method: 
  So we can declare the java main method with the following modifiers:
• Overloading Main method: We can overload main() with different types of parameters. 

class Test
{
    public static void main(String[] args)
    {
        System.out.println("Main Method String Array");
    }
    public static void main(int[] args)
    {
        System.out.println("Main Method int Array");
    }
}

Output:

Main Method String Array

• Inheritance of Main method: JVM Executes the main() without any errors. 

class A
{
    public static void main(String[] args)
    {
        System.out.println("Main Method Parent");
    }
}

class B extends A
{

}

Two class files, A.class and B.class are generated by a compiler. When we execute any of the two .class, JVM executes with no error. 

O/P: Java A
Main Method Parent
O/P: Java B
Main Method Parent

• Method Hiding of main(), but not Overriding: Since main() is static, derived class main() hides the base class main. (See Shadowing of static functions for details.) 

class A
{
    public static void main(String[] args)
    {
        System.out.println("Main Method Parent");
    }
}
class B extends A
{
    public static void main(String[] args)
    {
        System.out.println("Main Method Child");
    }
}

Two classes, A.class and B.class are generated by Java Compiler javac. When we execute both the .class, JVM executes with no error.

O/P: Java A
Main Method Parent
O/P: Java B
Main Method Child