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

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

public static void main(String[] args) 
  • ¿Qué es String[] args ?

  • ¿Cuándo args estos args ?

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

En Java args contiene los argumentos de la línea de comando suministrados como una matriz de objetos String .

En otras palabras, si ejecuta su progtwig como java MyProgram one two entonces args contendrá ["one", "two"] .

Si desea generar los contenidos 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 argumentos de línea de comandos en Java.

En otras palabras, si corres

java MyProgram uno dos

Entonces args contiene:

[ “uno dos” ]

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

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


Si eres nuevo en Java, te recomiendo que leas los Tutoriales Java TM de Oracle.

args contiene los argumentos de línea de comandos pasados ​​al progtwig Java al invocarlos. Por ejemplo, si invoco el progtwig de esta manera:

 $ java MyProg -f file.txt 

Entonces args será 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?

Respuesta->

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

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

P.ej
1) public static void main (argumento String [])

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

¿Cuándo usarías estos argumentos?

Respuesta->

La función principal está diseñada muy inteligentemente por los desarrolladores. El pensamiento real es muy profundo. Que básicamente se desarrolla bajo la consideración de C & C ++ basado en el argumento de la línea de comandos 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 comando puede ser Número o Cadena y es necesario para aceptarlo por el comstackdor, ¿qué tipo de datos deberíamos usar? ver lo 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 progtwig está comstackdo y ejecutado y también lo he probado.

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 } } 

String [] args es también la forma en que declaras una matriz de cadenas en Java.

En esta firma de método, las args la matriz se llenarán con valores cuando se llame al método (como se muestra en los otros ejemplos). Sin embargo, dado que estás aprendiendo, vale la pena entender que esta matriz args es como si hubieras creado una 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 } 

Me separaría

 public static void main(String args[]) 

en partes.

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

“estático” significa que main () no pertenece a un objeto específico

“void” significa que main () no devuelve ningún valor

“principal” es el nombre de una función. main () es especial porque es el inicio del progtwig.

“Cadena []” significa una matriz de Cadena.

“args” es el nombre de String [] (dentro del cuerpo de main ()). “args” no es especial; podrías ponerle otro nombre y el progtwig funcionaría igual.

  • String[] args es una colección de Strings, separados por un espacio, que se puede escribir en el progtwig en la terminal. Muchas veces, el principiante no va a usar esta variable, pero siempre está ahí por si acaso.

Cuando finalice su código, lo convertirá en un archivo con la extensión .java, que se puede ejecutar haciendo doble clic en él, pero también a través de una consola (terminal en un mac, cmd.exe en Windows) que permite al usuario 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ías la línea

 java -jar MyCode.jar 

después de navegar a la carpeta del progtwig con

 cd C:My/Code/Location 

en ventanas o

 cd My/Code/Location 

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

 java -jar MyCode.jar parameter1 parameter2 

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

Cuando una clase java se ejecuta 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 estrictamente requerida. Debería completar esta matriz en la línea de comando en la que invoque su progtwig

 java MyClass abc 

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

en public static void main (String args []) args es una matriz de argumento de línea de consola cuyo tipo de datos es String. en esta matriz, puede almacenar varios argumentos de cadena invocando 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] = “Royal”; usted puede hacer esto manualmente también dentro del progtwig, cuando no los llame en la línea de comando.

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

public static void main (String... args)

En otras palabras, el método main debe aceptar una matriz String ( String args[] ) o varargs ( String... args ) como argumento de método. Y tampoco hay magia con el nombre args . También podría escribir arguments o incluso freddiefujiwara como se muestra en la siguiente e.gs .:

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

Incluso si OP solo está hablando de String[] args , quiero dar un ejemplo completo de la 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 para cualquier Clase (si otras Clases pueden acceder a esta Clase).

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

Void : se usa para definir el Tipo de Retorno del Método. Define lo que el método puede devolver. No válido 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 nos fijamos en el código fuente de 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 llamarse main y debe tener la firma específica public static void main(String[] args)

El código también nos dice que el public static void main(String[] args) no es fijo, si cambia el código en (jdk-src \ j2se \ src \ share \ bin \ java.c) a otra firma, lo hará trabajar, 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.

Explicación en el lenguaje simple de un profano.

El método principal espera que proporcionemos algunos argumentos cuando direccionamos nuestra JVM al nombre de la clase. Eso significa, supongamos que su nombre de archivo es Try.java, ahora para ejecutar esto en el símbolo del sistema escriba “javac Try.java” para comstackr seguido de “java Try” para ejecutar. Ahora suponga que en lugar de escribir simplemente “java Try” escribe “java Try 1”. Aquí ha 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]); } 

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

Puede incluir argumentos en su progtwig usando la mayoría de los IDEs modernos

Por ejemplo, en Intellij puedes incluir argumentos haciendo:
Ejecutar -> Editar configuraciones … -> pestaña Configuración -> Argumentos del progtwig

enter image description here

Puede ver aquí que es más común dividir por espacios y si un nombre tiene espacios, puede usar comillas dobles para ajustarlo.

 public static void main(String[] args) { for(String arg: args) { System.out.println("arg " + arg); } } 

Este fragmento se imprimiría:

arg argument1
arg argument2
arg argumento nombre 3