Qu'est-ce que "String args []"? paramètre dans la méthode principale Java

Je commence tout juste à écrire des programmes en Java. Que signifie le code Java suivant?

public static void main(String[] args)

• Qu'est-ce que c'est String[] args?

• Quand les utiliseriez-vous args?

Le code source et / ou les exemples sont préférés aux explications abstraites

En Java, argscontient les arguments de ligne de commande fournis sous la forme d'un tableau d' Stringobjets.

En d'autres termes, si vous exécutez votre programme comme java MyProgram one twoalors argsle contiendra ["one", "two"].

Si vous souhaitez 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]);
        }
    }
}

Ce sont des arguments de ligne de commande en Java.

En d'autres termes, si vous exécutez

java MyProgram un deux

argsContient ensuite :

[ "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 s'exécute d'une manière particulière ou de lui fournir les informations dont elle a besoin.

Si vous êtes nouveau à Java, je recommande fortement la lecture par le biais de l'officiel Oracle Java ^TM tutoriels .

argscontient les arguments de ligne de commande passés au programme Java lors de l'appel. Par exemple, si j'appelle le programme comme ceci:

$ java MyProg -f file.txt

Il y argsaura alors 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 String.

args -> est le nom d'un tableau, il peut être n'importe quoi (par exemple a, ar, argument, param, paramètre) aucun problème avec le compilateur et exécuté et j'ai également testé.

Par exemple
1) public static void main (String [] argument)

2) public void main principal (paramètre String [])

Quand utiliseriez-vous ces arguments?

Ans->

La fonction principale est conçue très intelligemment par les développeurs. La pensée réelle est très profonde. Ce qui est essentiellement développé en tenant compte de C & C ++ basé sur l'argument de la ligne de commande, mais de nos jours, personne ne l'utilise plus.

Chose 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 nécessaire pour l'accepter par le compilateur quel type de données devons-nous utiliser? voir la chose 2

La chose 2- String est le type de données qui prend en charge tous les types de données primitifs comme int, long, float, double, byte, shot, char en Java. Vous pouvez facilement l'analyser dans n'importe quel type de données primitif.

Par exemple, le programme suivant est compilé et exécuté et j'ai également été 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    

  }
}

Même si OP ne parle que de String[] args, je veux donner un exemple complet de public static void main(String[] args).

Public: est un modificateur d'accès , qui définit qui peut accéder à cette méthode. Public signifie que cette méthode sera accessible par 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. Il est accessible 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. Ce nom de méthode est recherché par JVM comme 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 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 mainet doit avoir la signature spécifiquepublic static void main(String[] args)

Le code nous indique également que le public static void main(String[] args)n'est pas corrigé, si vous changez le code dans (jdk-src \ j2se \ src \ share \ bin \ java.c) en une autre signature, cela fonctionnera mais le changer vous donnera d'autres problèmes possibles à cause des spécifications java

Hors sujet: Cela fait 7 ans que OP a posé cette question, je suppose que OP peut maintenant répondre à sa propre question.

String [] args c'est aussi comment vous déclarez un tableau de chaînes en Java.

Dans cette signature de méthode, le tableau argssera rempli de valeurs lors de l'appel de la méthode (comme le montrent les autres exemples ici). Puisque vous apprenez cependant, il vaut la peine de comprendre que ce argstableau 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 casserais

public static void main(String args[])

en pièces détachées.

"public" signifie que main () peut être appelée de n'importe où.

"statique" signifie que main () n'appartient pas à un objet spécifique

"void" signifie que main () ne retourne 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 pourriez le nommer autrement et le programme fonctionnerait de la même manière.

• String[] argsest une collection de chaînes, séparées par un espace, qui peuvent être saisies dans le programme sur le terminal. Plus souvent qu'autrement, le débutant ne va pas utiliser cette variable, mais elle est toujours là juste au cas où.

Lorsque vous avez terminé votre code, vous le transformerez en un fichier avec l'extension .java, qui peut être exécuté en double-cliquant dessus, mais également dans une console (terminal sur un mac, cmd.exe sur Windows) qui permet à l'utilisateur de faire 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 des paramètres, donc normalement vous utiliseriez la ligne

java -jar MyCode.jar

après avoir accédé au dossier du programme avec

cd C:My/Code/Location

sur les fenêtres ou

cd My/Code/Location

sur Mac (notez que mac est moins maladroit) pour exécuter le 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 voulez permettre à l'utilisateur de contrôler des paramètres spéciaux tels que le fichier à utiliser ou la quantité de mémoire que le programme peut avoir. 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 n'importe quel nombre de paramètres peut être utilisé.

Explication en langage simple profane.

La méthode principale attend de nous que nous fournissions quelques arguments lorsque nous dirigeons notre machine virtuelle Java vers le nom de la classe. Cela signifie, supposons que votre nom de fichier est Try.java, maintenant pour l'exécuter dans l'invite de commande, vous écrivez "javac Try.java" à compiler suivi de "java Try" à exécuter. Supposons maintenant qu'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 souhaitez vérifier si votre méthode principale a réellement 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]);
    }

Je pense qu'il est assez bien couvert par les réponses ci-dessus qui String args[]sont simplement un tableau d'arguments de chaîne que vous pouvez transmettre à votre application lorsque vous l'exécutez. Pour terminer, je pourrais ajouter qu'il est également valide de définir le paramètre de méthode passé à la mainméthode en tant qu'argument variable (varargs) de type String:

public static void main (String... args)

En d'autres termes, la mainméthode doit accepter un tableau String ( String args[]) ou varargs ( String... args) comme argument de méthode. Et il n'y a pas non plus de magie avec le nom args. Vous pourriez aussi bien écrire argumentsou même freddiefujiwaracomme indiqué dans les e.gs ci-dessous:

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

Lorsqu'une classe java est exécutée à partir de la console, la méthode principale est ce qui est appelé. Pour que cela se produise, la définition de cette méthode principale doit être

public static void main(String [])

Le fait que ce tableau de chaînes soit appelé args est une convention standard, mais pas strictement requise. Vous rempliriez ce tableau à la ligne de commande lorsque vous appelez votre programme

java MyClass a b c

Ceux-ci sont couramment utilisés pour définir les options de votre programme, par exemple les fichiers sur lesquels écrire ou lire.

dans public static void main (String args []) args est un tableau d'arguments de ligne de console dont le type de données est String. dans ce tableau, vous pouvez stocker divers arguments de chaîne en les invoquant sur la ligne de commande comme indiqué ci-dessous: java myProgram Shaan Royal puis Shaan et Royal seront stockés dans le tableau sous la forme arg [0] = "Shaan"; arg [1] = "Royal"; vous pouvez le faire manuellement également à l'intérieur du programme, lorsque vous ne les appelez pas sur la ligne de commande.

Le style dataType[] arrayRefVarest préféré. Le style dataType arrayRefVar[]vient du langage C / C ++ et a été adopté en Java pour accueillir les programmeurs C / C ++.

le String[] args paramètre est un tableau de chaînes transmises en tant que paramètres lorsque vous exécutez votre application via la ligne de commande dans le système d'exploitation.

Imaginez donc que vous avez compilé et empaqueté une myApp.jarapplication Java. Vous pouvez exécuter votre application en double-cliquant dessus dans le système d'exploitation, bien sûr, mais vous pouvez également l'exécuter en utilisant la ligne de commande, comme (sous Linux, par exemple):

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

Lorsque vous appelez votre application en passant certains paramètres, comme:

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

La java -jarcommande passera vos chaînes updateet notifyvotre public static void main()méthode.

Vous pouvez alors faire quelque chose comme:

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

En plus de tous les commentaires précédents.

public static void main(String[] args) 

peut s'écrire

 public static void main(String...arg)

ou

 public static void main(String...strings)