¿Qué es "String args []"? parámetro en el método principal Java

Estoy empezando a escribir programas en Java. ¿Qué significa el siguiente código Java?

public static void main(String[] args)

• ¿Qué es String[] args?

• ¿Cuándo usarías estos args?

El código fuente y / o ejemplos son preferibles a las explicaciones abstractas

En Java argscontiene los argumentos de línea de comandos proporcionados como una matriz de Stringobjetos.

En otras palabras, si ejecuta su programa como java MyProgram one twoentonces argscontendrá ["one", "two"].

Si desea generar el contenido de args, puede recorrerlos de esta manera ...

public class ArgumentExample {
    public static void main(String[] args) {
        for(int i = 0; i < args.length; i++) {
            System.out.println(args[i]);
        }
    }
}

Esos son para argumentos de línea de comandos en Java.

En otras palabras, si corres

Java MyProgram uno dos

Luego argscontiene:

[ "uno dos" ]

public static void main(String [] args) {
    String one = args[0]; //=="one"
    String two = args[1]; //=="two"
}

La razón de esto es configurar su aplicación para que se ejecute de una manera particular o proporcionarle la información que necesita.

Si es nuevo en Java, le recomiendo leer los Tutoriales oficiales de Java ^{TM de} Oracle .

argscontiene los argumentos de la línea de comandos pasados ​​al programa Java tras la invocación. Por ejemplo, si invoco el programa así:

$ java MyProg -f file.txt

Luego argshabrá una matriz que contiene las cadenas "-f"y "file.txt".

La siguiente respuesta se basa en mi comprensión y alguna prueba.

¿Qué es String [] args?

Ans->

String [] -> Como sabemos, esta es una simple matriz de String.

args -> es el nombre de una matriz, puede ser cualquier cosa (por ejemplo, a, ar, argumento, parámetro, parámetro) sin problemas con el compilador y ejecutado y también probé.

Ejemplo:
1) main estático público vacío (argumento String [])

2) public static void main (parámetro String [])

¿Cuándo usarías estos args?

Ans->

La función principal está diseñada de manera muy inteligente por los desarrolladores. El pensamiento real es muy profundo. Básicamente se desarrolla bajo la consideración de C & C ++ basado en el argumento de la línea de comando pero hoy en día nadie lo usa más.

Cosa 1: el usuario puede ingresar cualquier tipo de datos desde la línea de comandos, ¿puede ser Número o Cadena? ¿Es necesario que el compilador lo acepte? ¿Qué tipo de datos deberíamos usar? ver la cosa 2

Thing 2- String es el tipo de datos que admite todos los tipos de datos primitivos como int, long, float, double, byte, shot, char en Java. Puede analizarlo fácilmente en cualquier tipo de datos primitivo.

Por ejemplo, el siguiente programa está compilado y ejecutado y también lo probé.

Si la entrada es -> 1 1

// one class needs to have a main() method
public class HelloWorld
{
  // arguments are passed using the text field below this editor
  public static void main(String[] parameter)
  {    
System.out.println(parameter[0] + parameter[1]); // Output is 11

//Comment out below code in case of String
    System.out.println(Integer.parseInt(parameter[0]) + Integer.parseInt(parameter[1])); //Output is 2
    System.out.println(Float.parseFloat(parameter[0]) + Float.parseFloat(parameter[1])); //Output is 2.0    
    System.out.println(Long.parseLong(parameter[0]) + Long.parseLong(parameter[1])); //Output is 2    
    System.out.println(Double.parseDouble(parameter[0]) + Double.parseDouble(parameter[1])); //Output is 2.0    

  }
}

Incluso aunque OP solo está hablando sobre el String[] args, quiero dar un ejemplo completo del public static void main(String[] args).

Public: es un modificador de acceso , que define quién puede acceder a este método. Público significa que este método será accesible por cualquier clase (si otras clases pueden acceder a esta clase).

Static: es una palabra clave que identifica la cosa relacionada con la clase. Esto significa que el Método o variable dado no está relacionado con la instancia, sino con la Clase. Se puede acceder sin crear la instancia de una clase.

Void: se utiliza para definir el tipo de retorno del método. Define lo que el método puede devolver. Anulado significa que el Método no devolverá ningún valor.

main: es el nombre del Método. JVM busca este nombre de método como punto de partida para una aplicación con una firma particular solamente.

String[] args : es el parámetro del método principal.

Si observa el código fuente JDK (jdk-src \ j2se \ src \ share \ bin \ java.c):

/* Get the application's main method */
mainID = (*env)->GetStaticMethodID(env, mainClass, "main",
                   "([Ljava/lang/String;)V");
...
{    /* Make sure the main method is public */
...
mods = (*env)->CallIntMethod(env, obj, mid);
if ((mods & 1) == 0) { /* if (!Modifier.isPublic(mods)) ... */
    message = "Main method not public.";
    messageDest = JNI_TRUE;
    goto leave;
...

Puede ver que el método de inicio en Java debe tener un nombre mainy debe tener la firma específicapublic static void main(String[] args)

El código también nos dice que public static void main(String[] args)no está solucionado, si cambia el código en (jdk-src \ j2se \ src \ share \ bin \ java.c) a otra firma, funcionará, pero cambiar esto le dará otros posibles problemas. debido a las especificaciones de Java

Offtopic: Han pasado 7 años desde que OP hizo esta pregunta, supongo que OP puede responder su propia pregunta por ahora.

String [] args también es cómo declaras una matriz de cadenas en Java.

En esta firma de método, la matriz argsse llenará con valores cuando se llame al método (como muestran los otros ejemplos aquí). Sin embargo, como estás aprendiendo, vale la pena entender que esta argsmatriz es como si hubieras creado uno tú mismo en un método, como en este:

public void foo() {
    String [] args = new String[2];
    args[0] = "hello";
    args[1] = "every";

    System.out.println("Output: " + args[0] + args[1]);

    // etc... the usage of 'args' here and in the main method is identical
}

Rompería

public static void main(String args[])

en partes.

"público" significa que se puede llamar a main () desde cualquier lugar.

"static" significa que main () no pertenece a un objeto específico

"vacío" significa que main () no devuelve ningún valor

"principal" es el nombre de una función. main () es especial porque es el inicio del programa.

"Cuerda[]" significa una matriz de String.

"args" es el nombre de la Cadena [] (dentro del cuerpo de main ()). "args" no es especial; podría nombrarlo de otra manera y el programa funcionaría igual.

• String[] argses una colección de cadenas, separadas por un espacio, que se pueden escribir en el programa en el terminal. La mayoría de las veces, el principiante no va a usar esta variable, pero siempre está ahí por si acaso.

Cuando termine su código, lo convertirá en un archivo con la extensión .java, que puede ejecutarse haciendo doble clic en él, pero también en una consola (terminal en una mac, cmd.exe en Windows) que permite al usuario hacer muchas cosas. Una cosa es que pueden ver los mensajes de la consola (System.out.print o System.out.println) que no pueden ver si hacen doble clic. Otra cosa que pueden hacer es especificar parámetros, por lo que normalmente usaría la línea

java -jar MyCode.jar

después de navegar a la carpeta del programa con

cd C:My/Code/Location

en ventanas o

cd My/Code/Location

en Mac (observe que Mac es menos torpe) para ejecutar el código, pero para especificar los parámetros que usaría

java -jar MyCode.jar parameter1 parameter2

Estos parámetros almacenados en la matriz de argumentos, que puede usar en su programa, es si desea permitir que el usuario controle parámetros especiales, como qué archivo usar o cuánta memoria puede tener el programa. Si desea saber cómo usar una matriz, probablemente pueda encontrar un tema en este sitio o simplemente buscarlo en Google. Tenga en cuenta que se puede usar cualquier número de parámetros.

Explicación en lenguaje simple.

El método principal espera que proporcionemos algunos argumentos cuando dirigimos nuestra JVM al nombre de la clase. Eso significa, suponga que su nombre de archivo es Try.java, ahora para ejecutar esto en el símbolo del sistema, escriba "javac Try.java" para compilar seguido de "java Try" para ejecutar. Ahora suponga que en lugar de escribir simplemente "Java Try" escribe "Java Try 1". Aquí has ​​pasado un argumento "1". Esto será tomado por su método principal, incluso si no lo usa en su código.

Si desea verificar si su método principal realmente ha tomado el argumento "1" o no. Simplemente, dentro de su método principal, escriba lo siguiente:

for(int i = 0; i < args.length; i++) {
        System.out.println("Argument is: "+args[i]);
    }

Creo que está bastante bien cubierto por las respuestas anteriores, que String args[]es simplemente una serie de argumentos de cadena que puede pasar a su aplicación cuando la ejecuta. Para completar, podría agregar que también es válido definir el parámetro del método pasado al mainmétodo como un argumento variable (varargs) de tipo String:

public static void main (String... args)

En otras palabras, el mainmétodo debe aceptar una matriz String ( String args[]) o varargs ( String... args) como argumento del método. Y tampoco hay magia con el nombre args. También podría escribir argumentso incluso freddiefujiwaracomo se muestra en los siguientes p. Ej .:

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

Cuando se ejecuta una clase java desde la consola, el método principal es lo que se llama. Para que esto suceda, la definición de este método principal debe ser

public static void main(String [])

El hecho de que este conjunto de cadenas se llame args es una convención estándar, pero no es estrictamente obligatorio. Rellenaría esta matriz en la línea de comando cuando invoque su programa

java MyClass a b c

Estos se usan comúnmente para definir las opciones de su programa, por ejemplo, archivos para escribir o leer.

en public static void main (String args []) args es una matriz de argumentos de línea de consola cuyo tipo de datos es String. en esta matriz, puede almacenar varios argumentos de cadena invocandolos en la línea de comando como se muestra a continuación: java myProgram Shaan Royal luego Shaan y Royal se almacenarán en la matriz como arg [0] = "Shaan"; arg [1] = "Real"; puedes hacer esto manualmente también dentro del programa, cuando no los llames en la línea de comando.

Se dataType[] arrayRefVarprefiere el estilo . El estilo dataType arrayRefVar[]proviene del lenguaje C / C ++ y fue adoptado en Java para acomodar a los programadores C / C ++.

El String[] argsparámetro es una matriz de cadenas pasadas como parámetros cuando ejecuta su aplicación a través de la línea de comandos en el sistema operativo.

Entonces, imagine que ha compilado y empaquetado una myApp.jaraplicación Java. Puede ejecutar su aplicación haciendo doble clic en el sistema operativo, por supuesto, pero también puede ejecutarla usando la línea de comandos, como (en Linux, por ejemplo):

user@computer:~$ java -jar myApp.jar

Cuando llama a su aplicación pasando algunos parámetros, como:

user@computer:~$ java -jar myApp.jar update notify

El java -jarcomando pasará sus cadenas updatey notifya su public static void main()método.

Luego puedes hacer algo como:

System.out.println(args[0]); //Which will print 'update'
System.out.println(args[1]); //Which will print 'notify'

Además de todos los comentarios anteriores.

public static void main(String[] args) 

Se puede escribir como

 public static void main(String...arg)

o

 public static void main(String...strings)