Che cos'è "String args []"? parametro nel metodo principale Java

Sto solo iniziando a scrivere programmi in Java. Cosa significa il seguente codice Java?

public static void main(String[] args)

• Che cosa è String[] args?

• Quando li useresti args?

Il codice sorgente e / o gli esempi sono preferiti rispetto alle spiegazioni astratte

In Java argscontiene gli argomenti della riga di comando forniti come una matrice di Stringoggetti.

In altre parole, se si esegue il programma come java MyProgram one twoallora argsconterrà ["one", "two"].

Se vuoi produrre i contenuti di args, puoi semplicemente farli scorrere in questo modo ...

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

Quelli sono per argomenti da riga di comando in Java.

In altre parole, se corri

java MyProgram uno due

Quindi argscontiene:

[ "uno due" ]

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

Il motivo di ciò è configurare l'applicazione in modo che esegua un determinato modo o fornisca alcune informazioni di cui ha bisogno.

Se non conosci Java, ti consiglio vivamente di leggere i tutorial Java ^TM Oracle ufficiali .

argscontiene gli argomenti della riga di comando passati al programma Java al momento dell'invocazione. Ad esempio, se invoco il programma in questo modo:

$ java MyProg -f file.txt

Quindi argssarà un array contenente le stringhe "-f"e "file.txt".

La seguente risposta si basa sulla mia comprensione e alcuni test.

Che cos'è String [] args?

Ans->

String [] -> Come sappiamo questo è un semplice array di stringhe.

args -> è il nome di un array, può essere qualsiasi cosa (es. a, ar, argomento, param, parametro) nessun problema con il compilatore ed eseguito e ho testato pure.

Ad esempio
1) public static void main (argomento String [])

2) public static void main (parametro String [])

Quando useresti questi argomenti?

Ans->

La funzione principale è progettata in modo molto intelligente dagli sviluppatori. Il pensiero reale è molto profondo. Fondamentalmente sviluppato tenendo conto di C & C ++ in base all'argomento della riga di comando, ma al giorno d'oggi nessuno lo usa più.

Cosa 1- L' utente può inserire qualsiasi tipo di dati dalla riga di comando può essere Numero o Stringa e necessario accettarlo dal compilatore quale tipo di dati dovremmo usare? vedi la cosa 2

Thing 2- String è il tipo di dati che supporta tutti i tipi di dati primitivi come int, long, float, double, byte, shot, char in Java. Puoi analizzarlo facilmente in qualsiasi tipo di dati primitivo.

Ad esempio, il seguente programma è compilato ed eseguito e anch'io ho testato.

Se l'ingresso è -> 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    

  }
}

Anche se OP sta solo parlando di String[] args, voglio fare un esempio completo di public static void main(String[] args).

Public: è un modificatore di accesso , che definisce chi può accedere a questo metodo. Pubblico significa che questo metodo sarà accessibile da qualsiasi classe (se altre classi sono in grado di accedere a questa classe).

Static: è una parola chiave che identifica la cosa relativa alla classe. Ciò significa che il metodo o la variabile forniti non sono correlati all'istanza ma alla classe. È possibile accedervi senza creare l'istanza di una classe.

Void: viene utilizzato per definire il tipo di ritorno del metodo. Definisce cosa può restituire il metodo. Vuoto significa che il metodo non restituirà alcun valore.

main: è il nome del metodo. Questo nome di metodo viene cercato da JVM come punto di partenza per un'applicazione con una firma specifica.

String[] args : è il parametro del metodo principale.

Se guardi nel codice sorgente 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;
...

Puoi vedere che il metodo iniziale in Java deve essere nominato maine deve avere la firma specificapublic static void main(String[] args)

Il codice ci dice anche che public static void main(String[] args)non è stato risolto, se si cambia il codice in (jdk-src \ j2se \ src \ share \ bin \ java.c) funzionerà con un'altra firma, funzionerà ma cambiarlo ti darà altri possibili problemi a causa delle specifiche Java

Offtopic: Sono passati 7 anni da quando OP ha fatto questa domanda, penso che ormai OP possa rispondere alla sua stessa domanda.

String [] args è anche il modo in cui dichiari un array di stringhe in Java.

In questa firma del metodo, l'array argsverrà riempito di valori quando viene chiamato il metodo (come mostrano gli altri esempi qui). Dal momento che stai imparando, vale la pena capire che questo argsarray è proprio come se tu ne avessi creato uno tu stesso in un metodo, come in questo:

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
}

Vorrei smettere

public static void main(String args[])

in parti.

"pubblico" significa che main () può essere chiamato da qualsiasi luogo.

"statico" significa che main () non appartiene a un oggetto specifico

"void" significa che main () non restituisce alcun valore

"main" è il nome di una funzione. main () è speciale perché è l'inizio del programma.

"String []" significa una matrice di String.

"args" è il nome della stringa [] (all'interno del corpo di main ()). "args" non è speciale; si potrebbe nominare qualsiasi altra cosa e il programma funzionerebbe allo stesso modo.

• String[] argsè una raccolta di stringhe, separate da uno spazio, che può essere digitata nel programma sul terminale. Più volte, il principiante non utilizzerà questa variabile, ma è sempre presente nel caso.

Quando finisci il tuo codice, lo trasformerai in un file con estensione .java, che può essere eseguito facendo doppio clic su di esso, ma anche attraverso una console (terminale su un mac, cmd.exe su Windows) che consente all'utente di fare molte cose. Una cosa è che possono vedere i messaggi della console (System.out.print o System.out.println) che non possono vedere se fanno doppio clic. Un'altra cosa che possono fare è specificare i parametri, quindi normalmente useresti la linea

java -jar MyCode.jar

dopo aver navigato nella cartella del programma con

cd C:My/Code/Location

su windows o

cd My/Code/Location

su Mac (nota che mac è meno ingombrante) per eseguire il codice, ma per specificare i parametri che useresti

java -jar MyCode.jar parameter1 parameter2

Questi parametri memorizzati nell'array args, che è possibile utilizzare nel programma, consentono all'utente di controllare parametri speciali come il file da utilizzare o la quantità di memoria che il programma può avere. Se vuoi sapere come usare un array, probabilmente potresti trovare un argomento su questo sito o semplicemente cercarlo su Google. Si noti che è possibile utilizzare qualsiasi numero di parametri.

Spiegazione in linguaggio semplice laico.

Il metodo principale prevede che forniamo alcuni argomenti quando indirizziamo la nostra JVM al nome della classe. Ciò significa che supponiamo che il nome del tuo file sia Try.java, ora per eseguirlo nel prompt dei comandi scrivi "javac Try.java" per la compilazione seguito da "java Try" per l'esecuzione. Ora supponi invece di scrivere semplicemente "java Try" scrivi "java Try 1". Qui hai passato un argomento "1". Questo sarà preso dal tuo metodo principale anche se non lo usi nel tuo codice.

Se vuoi verificare se il tuo metodo principale ha effettivamente preso l'argomento "1" o no. Semplicemente, all'interno del metodo principale digitare quanto segue:

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

Penso che sia abbastanza ben coperto dalle risposte sopra che String args[]è semplicemente una matrice di argomenti di stringa che puoi passare alla tua applicazione quando la esegui. Per il completamento, potrei aggiungere che è anche valido definire il parametro del metodo passato al mainmetodo come argomento variabile (varargs) di tipo String:

public static void main (String... args)

In altre parole, il mainmetodo deve accettare una stringa array ( String args[]) o varargs ( String... args) come argomento del metodo. E non c'è neanche magia con il nome args. Puoi anche scrivere argumentso anche freddiefujiwaracome mostrato di seguito ad es .:

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

Quando una classe java viene eseguita dalla console, il metodo principale è quello che viene chiamato. Affinché ciò accada, la definizione di questo metodo principale deve essere

public static void main(String [])

Il fatto che questo array di stringhe sia chiamato args è una convenzione standard, ma non strettamente richiesta. Popolerai questo array dalla riga di comando quando invocherai il tuo programma

java MyClass a b c

Questi sono comunemente usati per definire le opzioni del tuo programma, ad esempio i file su cui scrivere o da cui leggere.

in public static void main (String args []) args è un array di argomenti di riga console il cui tipo di dati è String. in questo array, è possibile memorizzare vari argomenti stringa invocandoli dalla riga di comando come mostrato di seguito: java myProgram Shaan Royal, quindi Shaan e Royal verranno memorizzati nell'array come arg [0] = "Shaan"; arg [1] = "reale"; puoi farlo manualmente anche all'interno del programma, quando non li chiami dalla riga di comando.

Lo stile dataType[] arrayRefVarè preferito. Lo stile dataType arrayRefVar[]deriva dal linguaggio C / C ++ ed è stato adottato in Java per ospitare i programmatori C / C ++.

Il String[] argsparametro è una matrice di stringhe passate come parametri quando si esegue l'applicazione tramite la riga di comando nel sistema operativo.

Quindi, immagina di aver compilato e impacchettato myApp.jarun'applicazione Java. Puoi eseguire la tua app facendo doppio clic su di essa nel sistema operativo, ovviamente, ma puoi anche eseguirla usando la riga di comando, come (ad esempio in Linux):

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

Quando chiami l'applicazione passando alcuni parametri, come:

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

Il java -jarcomando passerà le tue stringhe updatee notifyal tuo public static void main()metodo.

Puoi quindi fare qualcosa del tipo:

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

Oltre a tutti i commenti precedenti.

public static void main(String[] args) 

può essere scritto come

 public static void main(String...arg)

o

 public static void main(String...strings)