O que é "String args []"? parâmetro no método principal Java

Estou apenas começando a escrever programas em Java. O que significa o seguinte código Java?

public static void main(String[] args)

• O que é String[] args?

• Quando você os usaria args?

Código-fonte e / ou exemplos são preferidos a explicações abstratas

Em Java argscontém os argumentos de linha de comando fornecidos como uma matriz de Stringobjetos.

Em outras palavras, se você executar o seu programa como java MyProgram one two, em seguida, argsirá conter ["one", "two"].

Se você quiser exibir o conteúdo args, basta percorrer o conteúdo desta forma ...

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

Esses são para argumentos de linha de comando em Java.

Em outras palavras, se você executar

java MyProgram um dois

Então argscontém:

[ "um dois" ]

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

O motivo para isso é configurar seu aplicativo para executar uma maneira específica ou fornecer algumas informações necessárias.

Se você é novo no Java, recomendo a leitura dos tutoriais oficiais do Java ^TM da Oracle .

argscontém os argumentos da linha de comandos passados ​​para o programa Java na chamada. Por exemplo, se eu chamar o programa da seguinte maneira:

$ java MyProg -f file.txt

Então argshaverá uma matriz contendo as seqüências de caracteres "-f"e "file.txt".

A resposta a seguir é baseada no meu entendimento e em alguns testes.

O que é String [] args?

Resp->

String [] -> Como sabemos, este é um array de String simples.

args -> é o nome de uma matriz que pode ser qualquer coisa (por exemplo, a, ar, argumento, parâmetro, parâmetro) sem problemas com o compilador e executado e também testei.

Por exemplo,
1) public static void main (argumento String [])

2) main public void estático (parâmetro String [])

Quando você usaria esses argumentos?

Resp->

A principal função é projetada de maneira muito inteligente pelos desenvolvedores. O pensamento real é muito profundo. Que é basicamente desenvolvido sob consideração do C & C ++ com base no argumento da linha de comando, mas atualmente ninguém o usa mais.

Coisa 1 - O usuário pode inserir qualquer tipo de dado da linha de comando, pode ser Number ou String e necessário para aceitá-lo pelo compilador, que tipo de dados devemos usar? veja a coisa 2

Coisa 2 - String é o tipo de dados que suporta todos os tipos de dados primitivos, como int, long, float, double, byte, shot, char em Java. Você pode analisá-lo facilmente em qualquer tipo de dados primitivo.

Por exemplo, o programa a seguir é compilado e executado e eu testei também.

Se a entrada for -> 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    

  }
}

Mesmo que o OP esteja falando apenas sobre o String[] args, eu quero dar um exemplo completo do public static void main(String[] args).

Public: é um modificador de acesso , que define quem pode acessar esse método. Público significa que este método será acessível por qualquer classe (se outras classes puderem acessar essa classe).

Static: é uma palavra-chave que identifica a coisa relacionada à classe. Isso significa que o método ou a variável fornecida não está relacionada à instância, mas à classe. Ele pode ser acessado sem criar a instância de uma classe.

Void: é usado para definir o tipo de retorno do método. Ele define o que o método pode retornar. Anular significa que o Método não retornará nenhum valor.

main: é o nome do método. Este nome de método é procurado pela JVM como ponto de partida para um aplicativo apenas com uma assinatura específica.

String[] args : é o parâmetro para o método principal.

Se você procurar o código-fonte JDK (jdk-src \ j2se \ src \ compartilhamento \ 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;
...

Você pode ver que o método inicial em java deve ser nomeado maine ter a assinatura específicapublic static void main(String[] args)

O código também nos diz que public static void main(String[] args)não é fixo, se você alterar o código (jdk-src \ j2se \ src \ compartilhamento \ bin \ java.c) para outra assinatura, ele funcionará, mas alterar isso fornecerá outros possíveis problemas por causa das especificações do java

Offtopic: Já se passaram 7 anos desde que o OP fez essa pergunta, meu palpite é que o OP pode responder sua própria pergunta agora.

String [] args também é como você declara uma matriz de Strings em Java.

Nesta assinatura do método, a matriz argsserá preenchida com valores quando o método for chamado (como os outros exemplos aqui mostram). Como você está aprendendo, vale a pena entender que essa argsmatriz é como se você a tivesse criado em um método, como neste:

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
}

Eu terminaria

public static void main(String args[])

em partes.

"public" significa que main () pode ser chamado de qualquer lugar.

"estático" significa que main () não pertence a um objeto específico

"void" significa que main () não retorna valor

"main" é o nome de uma função. main () é especial porque é o início do programa.

"String []" significa uma matriz de String.

"args" é o nome da String [] (no corpo de main ()). "args" não é especial; você poderia nomear qualquer outra coisa e o programa funcionaria da mesma maneira.

• String[] argsé uma coleção de Strings, separadas por um espaço, que pode ser digitado no programa no terminal. Mais vezes do que não, o iniciante não vai usar essa variável, mas está sempre lá por precaução.

Quando você terminar o código, você o transformará em um arquivo com a extensão .java, que pode ser executada clicando duas vezes nele, mas também em um console (terminal em um mac, cmd.exe no windows), que permite ao usuário muitas coisas. Uma coisa é que eles podem ver as mensagens do console (System.out.print ou System.out.println) que não podem ver se clicarem duas vezes. Outra coisa que eles podem fazer é especificar parâmetros, então normalmente você usaria a linha

java -jar MyCode.jar

depois de navegar para a pasta do programa com

cd C:My/Code/Location

nas janelas ou

cd My/Code/Location

no Mac (observe que o mac é menos desajeitado) para executar código, mas para especificar parâmetros que você usaria

java -jar MyCode.jar parameter1 parameter2

Esses parâmetros armazenados na matriz args, que você pode usar em seu programa, é permitir que o usuário controle parâmetros especiais, como qual arquivo usar ou quanta memória o programa pode ter. Se você quiser saber como usar uma matriz, provavelmente poderá encontrar um tópico neste site ou apenas pesquisá-lo no Google. Observe que qualquer número de parâmetros pode ser usado.

Explicação em linguagem simples do leigo.

O método principal espera que forneçamos alguns argumentos quando direcionamos nossa JVM para o nome da classe. Isso significa que, suponha que seu nome de arquivo seja Try.java, agora, para executar isso no prompt de comando, você escreve "javac Try.java" para compilar, seguido de "java Try" para executar. Agora suponha que, em vez de escrever simplesmente "java Try", você escreva "java Try 1". Aqui você passou um argumento "1". Isso será utilizado pelo seu método principal, mesmo que você não o utilize no seu código.

Se você deseja verificar se o seu método principal realmente aceitou o argumento "1" ou não. Simplesmente, dentro do seu método principal, digite o seguinte:

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

Eu acho que é muito bem coberto pelas respostas acima, que String args[]é simplesmente uma matriz de argumentos de string que você pode passar para o seu aplicativo quando o executa. Para concluir, devo acrescentar que também é válido definir o parâmetro do método passado ao mainmétodo como um argumento variável (varargs) do tipo String:

public static void main (String... args)

Em outras palavras, o mainmétodo deve aceitar uma matriz String ( String args[]) ou varargs ( String... args) como argumento do método. E não há mágica com o nome argstambém. Você também pode escrever argumentsou até freddiefujiwaracomo mostrado abaixo, por exemplo:

public static void main (String[] arguments)

public static void main (String[] freddiefujiwara)

Quando uma classe java é executada no console, o método principal é o que é chamado. Para que isso aconteça, a definição deste método principal deve ser

public static void main(String [])

O fato de que essa matriz de cadeias de caracteres é chamada args é uma convenção padrão, mas não é estritamente necessária. Você preencheria essa matriz na linha de comando quando invocasse seu programa

java MyClass a b c

Eles são comumente usados ​​para definir opções do seu programa, por exemplo, arquivos nos quais gravar ou ler.

em público static void main (String args []) args é uma matriz de argumentos de linha do console cujo tipo de dados é String. nessa matriz, você pode armazenar vários argumentos de string chamando-os na linha de comando, como mostrado abaixo: java myProgram Shaan Royal, em seguida, Shaan e Royal serão armazenados na matriz como arg [0] = "Shaan"; arg [1] = "real"; você pode fazer isso manualmente também dentro do programa, quando não os chamar na linha de comando.

O estilo dataType[] arrayRefVaré preferido. O estilo dataType arrayRefVar[]vem da linguagem C / C ++ e foi adotado em Java para acomodar programadores em C / C ++.

o String[] args parâmetro é uma matriz de Strings passadas como parâmetros quando você está executando seu aplicativo através da linha de comando no SO.

Então, imagine que você tenha compilado e empacotado um myApp.jaraplicativo Java. Você pode executar seu aplicativo clicando duas vezes nele no sistema operacional, é claro, mas também pode executá-lo usando a linha de comando, como (no Linux, por exemplo):

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

Quando você chama seu aplicativo, passa alguns parâmetros, como:

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

O java -jarcomando passará suas Strings updatee notifypara o seupublic static void main() método.

Você pode fazer algo como:

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

Além de todos os comentários anteriores.

public static void main(String[] args) 

pode ser escrito como

 public static void main(String...arg)

ou

 public static void main(String...strings)