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:
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.
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
//Java code to understand that The Order of Modifiers don't mattersclass 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.
Java
class Test
{ public static void main(String[] args)
{
System.out.println("Main Method");
}
} |
Output:
Main Method
Java
class Test
{ public static void main(String []args)
{
System.out.println("Main Method");
}
} |
Output:
Main Method
Java
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:
Java
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
//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, eclipseclass 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.
Java
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
//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, eclipseclass 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
//Java code having Synchronized main method//please note these code may not run in gfg IDE, better run it on other IDEs e.g, eclipseclass 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
//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, eclipseclass 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.
Java
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.
Java
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.)
Java
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
Article Tags :
Recommended Articles