Sto solo iniziando a scrivere programmi in Java. Cosa significa il seguente codice Java?Che cos'è "String args []"? parametro nel metodo principale Java
cosa è String[] args?
Quando usereste questi args?
codice sorgente e/o esempi sono preferite rispetto alle spiegazioni astratte
args contiene gli argomenti della riga di comando passati al programma Java in base alla chiamata. Ad esempio, se invoco il programma in questo modo:
$ java MyProg -f file.txt
Poi args sarà una matrice contenente le stringhe "-f" e "file.txt".
In Java args contiene lo command-line arguments fornito come una matrice di oggetti String.
In altre parole, se si esegue il programma come java MyProgram one two allora args conterrà ["one", "two"].
Se si voleva in uscita il contenuto del args, si può solo ciclo attraverso di loro come questo ...
public class ArgumentExample {
public static void main(String[] args) {
for(int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
String [] args è anche come si dichiara un array di stringhe in Java.
In questa firma del metodo, l'array args verrà riempito con i valori quando viene chiamato il metodo (come mostrano gli altri esempi qui riportati). Dal momento che si sta imparando, però, vale la pena di capire che questo array args è proprio come se si è creato uno voi stessi 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
}
Quando una classe Java viene eseguito dalla console, il metodo principale è ciò che viene chiamato. Affinché ciò avvenga, la definizione di tale metodo principale deve essere
public static void main(String [])
Il fatto che questo array stringa è chiamato args è una convenzione standard, ma non strettamente necessaria. Si potrebbe compilare questo array alla linea di comando whne si richiama il programma di
java MyClass a b c
Questi sono comunemente usati per definire le opzioni del programma, ad esempio i file da scrivere o leggere da.
Questi sono per gli argomenti della riga di comando in Java.
In altre parole, se si esegue
java MyProgram uno due
Poi args contiene:
[ "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 per eseguire un particu modo o fornirgli alcune informazioni di cui ha bisogno.
Se siete nuovi a Java, mi raccomando di leggere attraverso l'ufficiale di Oracle JavaTM Tutorials.
in void main (String args []) statici pubblici args è un array di argomento della linea di console con tipo di dati String. in questo array, è possibile memorizzare i vari argomenti stringa da loro invocando nella riga di comando come illustrato di seguito: java myProgram Shaan Reale poi Shaan e Royal saranno memorizzati nella matrice come arg [0] = "Shaan" ; arg [1] = "Royal"; puoi farlo manualmente anche all'interno del programma, quando non li chiami dalla riga di comando.
Al termine del codice, lo trasformerai in un file con estensione .java, che può essere eseguito facendo doppio clic su di esso, ma anche su una console (terminale su mac, cmd.exe su Windows) che lascia che l'utente faccia 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, così normalmente si usa 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 (notare che mac è meno goffo) per eseguire il codice, ma per specificare i parametri si usa
java -jar MyCode.jar parameter1 parameter2
Questi parametri memorizzati nell'array args, che è possibile utilizzare nel programma, consentono all'utente di controllare parametri speciali quali il file da utilizzare o la quantità di memoria che può avere il programma. Se vuoi sapere come usare un array, probabilmente potresti trovare un argomento su questo sito o solo su google. Si noti che è possibile utilizzare qualsiasi numero di parametri.
Penso che sia abbastanza ben coperto dalle risposte sopra che String args[] è semplicemente un array di argomenti stringa che è possibile passare all'applicazione quando viene eseguita.Per il completamento, mi permetto di aggiungere che è valida anche per definire il parametro del metodo passato al metodo main come argomento di variabili (varargs) di tipo String:
public static void main (String... args)
In altre parole, il metodo main deve accettare o un array di stringhe (String args[]) o vararg (String... args) come argomento del metodo. E non c'è magia con il nome args neanche. Si potrebbe anche scrivere arguments o addirittura freddiefujiwara come mostrato in e.gs sotto .:
public static void main (String[] arguments)
public static void main (String[] freddiefujiwara)
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++.
Spiegazione nella lingua semplice di un laico.
Il metodo principale prevede di fornire alcuni argomenti quando indirizziamo la nostra JVM al nome della classe. Ciò significa, supponiamo che il tuo nome file sia Try.java, ora per eseguirlo nel prompt dei comandi scrivi "javac Try.java" da compilare seguito da "java Try" da eseguire. Ora supponiamo invece di scrivere semplicemente "java Try" per scrivere "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 si desidera verificare se il metodo principale ha effettivamente preso l'argomento "1" o meno. Semplicemente, all'interno del vostro tipo di metodo principale il seguente:
for(int i = 0; i < args.length; i++) {
System.out.println("Argument is: "+args[i]);
}
Anche tho OP sta parlando solo della String[] args, voglio dare un esempio completo del public static void main(String[] args).
Public: è un Access Modifier, 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 correlata alla classe. Questo significa che il metodo o la variabile data non è correlata 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 ciò che il metodo può restituire. Vuoto significa che il Metodo non restituirà alcun valore.
main: è il nome del metodo. Questo nome metodo viene cercato da JVM come punto di partenza per un'applicazione con una sola firma specifica.
String[] args: è il parametro del Metodo principale.
Se si esamina il 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;
...
Si può vedere che la starting method in Java deve essere chiamato main e deve avere la firma specifica public static void main(String[] args)
Il codice ci dice anche che il public static void main(String[] args) non è fisso, se si modifica il codice a (JDK-src \ J2SE \ src \ share \ bin \ java.c) ad un'altra firma, funzionerà ma cambiare questo vi darà altre possibili problemi a causa del java specs
offtopic: E 'stato 7 anni dopo che l'OP ha posto questa domanda, la mia ipotesi è che l'OP possa rispondere alla sua stessa domanda ormai.
vorrei spezzare
public static void main(String args[])
in parti.
"public" significa che main() può essere chiamato da qualsiasi luogo.
"statico" significa che main() non appartiene a un oggetto specifico
"vuoto" significa che main() restituisce alcun valore
"principale" è il nome di una funzione. main() è speciale perché è l'inizio del programma.
"String []" indica un array di String.
"args" è il nome della stringa [] (all'interno del corpo di main()). "args" non è speciale; potresti chiamarlo qualsiasi altra cosa e il programma funzionerebbe allo stesso modo.
String[] args è una raccolta di stringhe, separate da uno spazio, che possono essere digitate nel programma sul terminale. Più volte, il principiante non userà questa variabile, ma è sempre lì per ogni evenienza.La seguente risposta è basata sulla mia comprensione & alcuni test.
Che cos'è String [] args?
Ans->
String [] -> Come sappiamo che questo è un semplice array String.
args -> è il nome di un array può essere qualsiasi cosa (ad esempio una, ar, argomento, param, parametro) nessun problema con il compilatore & eseguito & ho provato pure.
E.g.
1) void main (String [] argomento public static)
2) parametro public static void main (String [])
Quando volete utilizzare questi argomenti?
Ans->
La funzione principale è progettato intelligentemente dagli sviluppatori. Il pensiero reale è molto profondo. Che è fondamentalmente sviluppato in considerazione di C & C++ basato sull'argomento della riga di comando ma oggigiorno nessuno lo usa di più.
Thing 1- utente può inserire qualsiasi tipo di dati dalla linea di comando può essere numero o una stringa & necessario accettarla dal compilatore, che tipo di dati dovremmo usare? see the thing 2
Cosa è il tipo di dati che supporta tutti i tipi di dati primitivi come int, long, float, double, byte, shot, char in Java. Puoi facilmente analizzarlo in qualsiasi tipo di dati primitivo.
es Il seguente programma viene compilato & eseguito & ho provato pure.
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
}
}
degno di nota è che 'args' non deve necessariamente essere chiamato' args' (si può chiamare come volete) - anche se è meglio seguire convenzione. Si potrebbe anche vedere 'String ... args' di volta in volta, che è equivalente. – vikingsteve
l'indicizzazione degli indici parte da 0. (contrariamente a C che fornisce il nome del programma) – AdrieanKhisbe
@Daniel, 'args' è garantito che sia separato dallo spazio indipendentemente dal sistema operativo? – Pacerier