Usando argumentos de linha de comando em Java

Os argumentos da linha de comandos podem ser uma maneira de especificar propriedades de configuração para um aplicativo, e Java não é diferente. Em vez de clicar no ícone de um aplicativo no sistema operacional, você pode executar o Java aplicação a partir de uma janela do terminal. Juntamente com o nome do aplicativo, podem ser seguidos vários argumentos que são passados para o ponto inicial do aplicativo (ou seja, o método principal, no caso de Java).

Por exemplo, NetBeans tem vários parâmetros de inicialização que podem ser passados para o aplicativo quando ele é executado a partir de uma janela do terminal (por exemplo,

especifica uma versão do JDK a ser usada em vez do JDK padrão associado ao aplicativo NetBeans).

O método principal

Vamos examinar o método principal para ver onde os argumentos passados para um aplicativo são exibidos:

Os argumentos da linha de comando podem ser encontrados no diretório

chamado

Por exemplo, vamos considerar um aplicativo chamado

cuja única ação é imprimir os argumentos da linha de comando passados para ele:

instagram viewer

classe pública CommandLineArgs {

 public static void main (String [] args) {
// verifica se a matriz String está vazia
if (args.length == 0)
{
System.out.println ("Não foram transmitidos argumentos da linha de comandos!");
}

 // Para cada String na matriz String
// imprime a String.
for (Argumento de sequência: args)
{
System.out.println (argumento);
}
}
}

Sintaxe dos argumentos da linha de comando

O Java Runtime Engine (JRE) espera que os argumentos sejam transmitidos seguindo uma sintaxe específica, da seguinte forma:

java ProgramName value1 value2

Acima, "java" chama o JRE, que é seguido pelo nome do programa que você está chamando. Estes são seguidos por quaisquer argumentos para o programa. Não há limite para o número de argumentos que um programa pode receber, mas a ordem é crítica. O JRE passa os argumentos na ordem em que aparecem na linha de comandos. Por exemplo, considere este trecho de código acima:

classe pública CommandLineArgs2 {

 public static void main (String [] args) {
if (args.length == 0)
{
System.out.println ("Não foram transmitidos argumentos da linha de comandos!");
}

Quando argumentos são passados para um programa Java, args [0] é o primeiro elemento da matriz (valor1 acima), args [1] é o segundo elemento (valor2) e assim por diante. O código args.length () define o comprimento da matriz.

Passando argumentos de linha de comando

No NetBeans, podemos passar argumentos de linha de comando sem precisar criar o aplicativo e executá-lo a partir de uma janela do terminal. Para especificar os argumentos da linha de comando:

Clique com o botão direito do mouse na pasta do projeto no diretório
```
Projetos
```
janela.
Escolha o
```
Propriedades
```
opção de abrir
```
Propriedades do Projeto
```
janela.
No
```
Categorias
```
lista no lado direito, escolha
```
Corre
```
No
```
Argumentos
```
Na caixa de texto exibida, especifique os argumentos da linha de comando que você deseja passar para o aplicativo. Por exemplo, se inserirmos
```
Cenoura com banana e maçã
```
no
```
Argumentos
```
caixa de texto e execute o
```
CommandLineArgs
```
programa listado acima, obteremos a saída:

Analisando os argumentos da linha de comando

Normalmente, um argumento de linha de comando é passado com algumas informações sobre o que fazer com o valor que está sendo passado. O argumento que informa ao aplicativo para que serve o argumento geralmente possui um hífen ou dois antes de seu nome. Por exemplo, o exemplo do NetBeans para o parâmetro de inicialização que especifica o caminho do JDK é

Isso significa que você precisará analisar os argumentos da linha de comando para descobrir o que fazer com os valores. Existem várias estruturas de linha de comando Java para analisar argumentos de linha de comando. Ou você pode escrever um analisador de linha de comando simples se os argumentos que você precisa passar não são muitos:

o código acima imprime os argumentos ou os adiciona se forem inteiros. Por exemplo, este argumento da linha de comando adicionaria os números:

java CommandLineArgs - números 11 22 33 44