Qu'est-ce que "String args []"? paramètre dans la méthode principale Java
Je commence juste à écrire des programmes en Java. Que signifie le code Java suivant?
public static void main(String[] args)
Qu'est-ce que
String[] args?Quand utiliseriez-vous ces
args?
Le code source et/ou les exemples sont préférés aux explications abstraites
En Java, args contient les arguments de ligne de commande fournis sous forme de tableau d'objets String.
En d'autres termes, si vous exécutez votre programme en tant que Java MyProgram one two, alors args contiendra ["one", "two"].
Si vous voulez afficher le contenu de args, vous pouvez simplement les parcourir comme ceci ...
public class ArgumentExample {
public static void main(String[] args) {
for(int i = 0; i < args.length; i++) {
System.out.println(args[i]);
}
}
}
Ceux-ci sont pour les arguments de ligne de commande en Java.
En d'autres termes, si vous courez
Java MyProgram un deux
Alors args contient:
[ "un deux" ]
public static void main(String [] args) {
String one = args[0]; //=="one"
String two = args[1]; //=="two"
}
La raison en est de configurer votre application pour qu’elle fonctionne de manière particulière ou de lui fournir certaines informations nécessaires.
Si vous débutez dans Java, je vous recommande vivement de lire le journal officiel d'Oracle Java.TM Tutoriels .
args contient les arguments de ligne de commande passés au programme Java lors de l'appel. Par exemple, si j'appelle le programme comme suit:
$ Java MyProg -f file.txt
Alors args sera un tableau contenant les chaînes "-f" et "file.txt".
La réponse suivante est basée sur ma compréhension et certains tests.
Qu'est-ce que String [] args?
Ans->
String [] -> Comme nous le savons, il s’agit d’un simple tableau de chaînes.
args -> est le nom d'un tableau qui peut être n'importe quoi (par exemple, un ar, un argument, un paramètre, un paramètre) sans problème avec le compilateur & exécuté & j'ai également testé.
Par exemple.
1) public static void main (argument String [])
2) public static void main (paramètre String [])
Quand utiliseriez-vous ces arguments?
Ans->
La fonction principale est conçue de manière très intelligente par les développeurs. La pensée réelle est très profonde . Ce qui est fondamentalement développé en tenant compte de C & C++ basé sur l'argument de ligne de commande, mais de nos jours, personne ne l'utilise plus.
Thing 1- L'utilisateur peut entrer n'importe quel type de données à partir de la ligne de commande peut être un nombre ou une chaîne et être nécessaire pour l'accepter par le compilateur, quel type de données faut-il utiliser? voir la chose 2
Thing 2- String est le type de données qui prend en charge tous les types de données primitifs tels que int, long, float, double, octet, shot, char en Java. Vous pouvez facilement l'analyser dans n'importe quel type de données primitif.
E.g Le programme suivant est compilé et exécuté et j’ai également testé.
Si l'entrée est -> 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 permet également de déclarer un tableau de chaînes en Java.
Dans cette signature de méthode, le tableau args sera rempli de valeurs lors de l'appel de la méthode (comme le montrent les autres exemples ici). Puisque vous apprenez cependant, il est bon de comprendre que ce tableau args est comme si vous en aviez créé un vous-même dans une méthode, comme dans ceci
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
}
Je romprais
public static void main(String args[])
dans les parties.
"public" signifie que main () peut être appelé de n'importe où.
"static" signifie que main () n'appartient pas à un objet spécifique
"void" signifie que main () ne renvoie aucune valeur
"main" est le nom d'une fonction. main () est spécial car c'est le début du programme.
"String []" signifie un tableau de String.
"args" est le nom de la chaîne [] (dans le corps de main ()). "args" n'est pas spécial; vous pouvez nommer n'importe quoi d'autre et le programme fonctionnerait de la même manière.
String[] argsest un ensemble de chaînes, séparées par un espace, pouvant être saisi dans le programme du terminal. Plus souvent qu'autrement, le débutant n'utilisera pas cette variable, mais sera toujours là au cas où.
Lorsque vous avez terminé votre code, vous le transformez en un fichier avec l'extension .Java, que vous pouvez exécuter en double-cliquant dessus, mais également dans une console (terminal sur un mac, cmd.exe sur Windows) qui permet à l'utilisateur de plusieurs choses. Une chose est qu'ils peuvent voir les messages de la console (System.out.print ou System.out.println) qu'ils ne peuvent pas voir s'ils double-cliquent. Une autre chose qu’ils peuvent faire est de spécifier les paramètres, donc vous utiliseriez normalement la ligne
Java -jar MyCode.jar
après avoir accédé au dossier du programme avec
cd C:My/Code/Location
sur des fenêtres ou
cd My/Code/Location
sur Mac (notez que mac est moins clunky) pour exécuter du code, mais pour spécifier les paramètres que vous utiliseriez
Java -jar MyCode.jar parameter1 parameter2
Ces paramètres stockés dans le tableau args, que vous pouvez utiliser dans votre programme si vous souhaitez permettre à l'utilisateur de contrôler des paramètres spéciaux, tels que le fichier à utiliser ou la quantité de mémoire dont dispose le programme. Si vous voulez savoir comment utiliser un tableau, vous pouvez probablement trouver un sujet sur ce site ou simplement le rechercher sur Google. Notez que vous pouvez utiliser n'importe quel nombre de paramètres.
Même si l'OP ne parle que du String[] args, je veux donner un exemple complet de la public static void main(String[] args).
Public: est un Access Modifier , qui définit qui peut accéder à cette méthode. Public signifie que cette méthode sera accessible à n'importe quelle classe (si d'autres classes peuvent accéder à cette classe.).
Static: est un mot clé qui identifie la chose liée à la classe. Cela signifie que la méthode ou la variable donnée n'est pas liée à l'instance mais à la classe. On peut y accéder sans créer l'instance d'une classe.
Void: est utilisé pour définir le type de retour de la méthode. Il définit ce que la méthode peut renvoyer. Void signifie que la méthode ne renverra aucune valeur.
main: est le nom de la méthode. JVM recherche le nom de cette méthode en tant que point de départ pour une application avec une signature particulière uniquement.
String[] args: est le paramètre de la méthode principale.
Si vous examinez le code source du 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;
...
Vous pouvez voir que la méthode de démarrage en Java doit être nommée main et doit avoir la signature spécifique public static void main(String[] args)
Le code nous indique également que la public static void main(String[] args) n’est pas corrigée. Si vous modifiez le code dans (jdk-src\j2se\src\share\bin\Java.c) en une autre signature, cela fonctionnera, mais sa modification vous donnera d’autres possibilités. problèmes à cause de Java specs
Offtopic: Cela fait 7 ans que OP a posé cette question, je pense qu'OP peut désormais répondre à sa propre question.
Lorsqu'une classe Java est exécutée à partir de la console, la méthode principale est appelée. Pour ce faire, la définition de cette méthode principale doit être
public static void main(String [])
Le fait que ce tableau de chaînes s'appelle args est une convention standard, mais pas strictement requise. Vous devez renseigner ce tableau sur la ligne de commande lorsque vous appelez votre programme
Java MyClass a b c
Celles-ci sont couramment utilisées pour définir les options de votre programme, par exemple les fichiers à écrire ou à lire.
Explication en langage simple profane.
La méthode principale attend de nous que nous fournissions des arguments lorsque nous dirigeons notre JVM vers le nom de la classe. Cela signifie que supposons que votre nom de fichier est Try.Java, maintenant pour l’exécuter dans la commande Invite vous écrivez "javac Try.Java" à compiler suivi de "Java Try" à exécuter. Supposons maintenant, au lieu d'écrire simplement "Java Try", vous écrivez "Java Try 1". Ici vous avez passé un argument "1". Cela sera pris par votre méthode principale même si vous ne l'utilisez pas dans votre code.
Si vous voulez vérifier si votre méthode principale a bien pris l'argument "1" ou non. Simplement, dans votre méthode principale, tapez ce qui suit:
for(int i = 0; i < args.length; i++) {
System.out.println("Argument is: "+args[i]);
}
in public static void main (String args []) args est un tableau d'arguments de lignes de console dont le type de données est String . Dans ce tableau, vous pouvez stocker différents arguments de chaînes en appelant Dans la ligne de commande, comme indiqué ci-dessous: Java monProgramme Shaan Royal Ensuite, Shaan et Royal seront stockés dans le tableau sous la forme arg [0] = "Shaan"; arg. [1] = "Royal"; Vous pouvez le faire manuellement aussi à l’intérieur du programme, lorsque vous ne les appelez pas en ligne de commande.
Le style dataType[] arrayRefVar est préféré. Le style dataType arrayRefVar[] provient du langage C/C++ et a été adopté en Java pour s'adapter aux programmeurs C/C++.
En plus de tous les commentaires précédents.
public static void main(String[] args)
peut être écrit comme
public static void main(String...arg)
ou
public static void main(String...strings)