Variantes válidas de main() en Java

Sabemos que un código Java comienza a ejecutarse desde el método principal. Durante el tiempo de ejecución, si JVM no puede encontrar ningún método principal, obtendremos una excepción de tiempo de ejecución: 
No such Method Error : 
 

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

para evitar este problema debe haber el método principal. También sabemos que el método principal de Java tiene un prototipo particular, que se ve así: 
 

public static void main(String[] args)

 
Aunque la sintaxis anterior (prototipo) es muy estricta, se aceptan algunos pequeños cambios. Esto hace que no sea tan estricto que si realizamos algún cambio, obtendremos una excepción de tiempo de ejecución. Podemos hacer varias modificaciones permitidas a nuestro método principal. 
Los siguientes cambios son aceptables. 
Comprendamos las diferentes variantes de main() que son válidas.
 

• Prototipo predeterminado: a continuación se muestra la forma más común de escribir main() en Java. 

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

Producción:

Main Method

Significado de la sintaxis principal: 

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.
 

• Orden de Modificadores: Podemos intercambiar posiciones de static y public en 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");
    }
}

Producción:

Main Method

• Variantes de argumentos de array de strings: podemos colocar corchetes en diferentes posiciones para el parámetro de string. 

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

Producción:

Main Method

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

Producción:

Main Method

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

Producción:

Main Method

• Argumentos o cualquier cosa: en lugar de argumentos, podemos escribir cualquier cosa que sea un identificador válido de Java. Puede escribir cualquier cosa aquí, puede escribir su nombre o el nombre de la empresa o cualquier cosa que desee escribir, pero debe seguir la regla de ser un identificador de Java. 
  Ejemplo: 

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

Producción: 

Instead of args we have written geeksforgeeks

• Var-args en lugar de array de strings: de acuerdo con la regla, siempre que haya una array unidimensional, podemos reemplazar la array con el parámetro var-arg. Así que aquí podemos cambiar nuestra array de strings usando var-args. (los puntos triples en lugar de []) 
  Ejemplo: 

//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");
    }
}

Producción: 

Var-args main method

• Argumento de string de modificador final: podemos hacer que String args[] sea final. 

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

Producción:

Main Method

• Método principal final: Podemos declarar el método principal con la palabra clave final. Esto no puede cambiar la ejecución ni dar ningún error. 
  Ejemplo: 
   

//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");
 
        }
}

Producción: 

final main method

• palabra clave sincronizada con el método principal estático: Podemos sincronizar main(). 

//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");
    }
}

Producción:

Main Method

• Palabra clave strictfp para el método principal estático: strictfp se puede utilizar para restringir los cálculos de punto flotante. 
   

//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");
    }
}

Producción:

Main Method

• Combinaciones de todas las palabras clave anteriores con el método principal estático: 
  podemos declarar el método principal de Java con los siguientes modificadores:
• Sobrecarga del método Main: Podemos sobrecargar main() con diferentes tipos de parámetros. 

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");
    }
}

Producción:

Main Method String Array

• Herencia del método Main: JVM Ejecuta main() sin ningún error. 

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

Un compilador genera dos archivos de clase, A.class y B.class. Cuando ejecutamos cualquiera de los dos .class, JVM se ejecuta sin error. 

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

• Método Ocultación de main(), pero no anulación: dado que main() es estático, la clase derivada main() oculta la clase base main. (Consulte Sombreado de funciones estáticas para obtener más detalles). 

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");
    }
}

Java Compiler javac genera dos clases, A.class y B.class. Cuando ejecutamos ambos .class, JVM se ejecuta sin error.

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

Este artículo es una contribución de Mahesh . Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.