Argumentos de Linha de Comando em Java Explicados: Do Básico aos Padrões de Design Práticos

1. Introdução

Propósito deste Capítulo

Os argumentos de linha de comando em Java são um recurso fundamental que permite que os programas recebam valores externos em tempo de execução e alterem seu comportamento de acordo. Este artigo explica tudo, desde o significado de String[] args até padrões de design práticos usados em aplicações reais. Neste capítulo, primeiro esclarecemos o que os argumentos de linha de comando podem fazer e em quais situações eles são úteis.

O que são Argumentos de Linha de Comando?

Uma aplicação Java normalmente inicia a partir de um método main com a seguinte assinatura:

public class App {
    public static void main(String[] args) {
        // args is an array of strings passed at runtime
    }
}

args é um array de strings que armazena os valores fornecidos quando o programa é iniciado. Por exemplo:

javac App.java
java App Tokyo 2025 debug

Neste caso, args contém ["Tokyo", "2025", "debug"].
Se nenhum argumento for fornecido, args.length será 0.

Casos de Uso Comuns

• Trocar ambientes ou alvos: modo produção vs teste, códigos de região, idiomas, níveis de log.
• Especificar alvos de processamento externamente: nomes de arquivos de entrada, diretórios, URLs, listas de IDs.
• Processamento em lote e automação: passar datas ou intervalos para jobs agendados, injetar parâmetros a partir de pipelines CI/CD.

Em todos os casos, o comportamento pode ser alterado sem recompilar, tornando os argumentos de linha de comando ideais para uso com scripts de shell e agendadores de tarefas como o cron.

Considerações de Design Principais

• Separar argumentos obrigatórios e opcionais: se argumentos mandatórios estiverem ausentes, falhe de forma clara com saída de ajuda ou códigos de saída.
• Validar cedo: converta valores numéricos ou de data o quanto antes e forneça orientações claras sobre entradas inválidas.
• Definir valores padrão: argumentos opcionais devem ter valores seguros padrão para que o programa ainda possa ser executado.
• Legibilidade e manutenção: evite espalhar acessos diretos ao array; analise os argumentos em objetos estruturados (DTOs ou classes de configuração).

Escolhendo entre Argumentos, Variáveis de Ambiente e Arquivos de Configuração

• Argumentos de linha de comando: melhores para sobrescritas temporárias ou configurações específicas de job (prioridade mais alta, configuração local).
• Variáveis de ambiente: adequadas para segredos ou endpoints que variam por ambiente de implantação.
• Arquivos de configuração (properties/JSON/YAML): ideais para gerenciar múltiplas configurações de forma sistemática, com reutilização e controle de versão.

Na prática, um design em três camadas — arquivos de configuração + variáveis de ambiente + argumentos de linha de comando — funciona bem, com os argumentos de linha de comando tendo a maior precedência.

Exemplo Minimalista: Listando Todos os Argumentos

public class ArgsEcho {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No arguments were provided.");
            System.out.println("Example: java ArgsEcho input.txt debug");
            return;
        }
        System.out.println("Received arguments:");
        for (int i = 0; i < args.length; i++) {
            System.out.printf("args[%d] = %s%n", i, args[i]);
        }
    }
}

O que este Artigo Abordará a Seguir (Roteiro)

• Operações básicas em String[] args (verificações de comprimento, acesso a elementos)
• Conversão de tipos (int/double/boolean e tratamento de exceções)
• Formatos de opção como -v, --help e --mode=prod
• Configuração de IDE e como passar argumentos durante testes
• Tratamento de erros e considerações de segurança (entrada inválida, gerenciamento de exceções)
• Exemplos práticos (processamento de arquivos, troca de modo, controle de nível de log)

Primeiro, lembre‑se deste princípio central: todos os argumentos são passados como strings e devem ser convertidos e validados com segurança antes do uso. No próximo capítulo, exploraremos a sintaxe básica e os padrões comuns com exemplos de código concretos.

2. O que são Argumentos de Linha de Comando?

A Relação entre o método main e String[] args

O ponto de entrada de uma aplicação Java é o método main, definido da seguinte forma:

public static void main(String[] args)

Aqui, args representa “argumentos” e é um array de strings que armazena valores passados de fora quando o programa inicia.
Quando você executa um programa, os valores especificados após java NomeDaClasse, separados por espaços, são armazenados sequencialmente em args.

Exemplo: Executando com Argumentos

javac Sample.java
java Sample apple orange banana

Neste caso, o conteúdo de args é o seguinte:

Em outras palavras, args se comporta como uma lista de strings de comprimento variável, permitindo que você passe qualquer número de valores.
Se nenhum argumento for especificado, args.length torna‑se 0 (ele nunca é null).

Exemplo de Execução e Saída

public class Sample {
    public static void main(String[] args) {
        System.out.println("Number of arguments: " + args.length);
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

java Sample dog cat

Saída:

Number of arguments: 2
args[0] = dog
args[1] = cat

O ponto importante aqui é que todos os argumentos são recebidos como strings.
Se você quiser usá‑los como números ou valores booleanos, deve convertê‑los explicitamente depois.

Quando Você Deve Usar Argumentos de Linha de Comando?

Argumentos de linha de comando são comumente usados nos seguintes cenários:

• Alternar modos de operação Exemplo: java Server start vs java Server stop para executar ações diferentes.
• Especificar caminhos de arquivos ou valores de configuração Exemplo: java ReportGenerator /data/input.csv
• Passar parâmetros temporários durante a execução de scripts Exemplo: datas, nomes de usuário ou como substitutos leves de variáveis de ambiente.

Esses casos de uso aumentam a flexibilidade e permitem que os programas sejam controlados por entrada externa sem recompilação.

Comportamento Quando Nenhum Argumento é Fornecido

O método main em Java sempre inclui String[] args, mesmo quando nenhum argumento é passado.
Se o programa for executado sem argumentos, args.length == 0, portanto recomenda‑se adicionar uma verificação condicional como a seguinte:

if (args.length == 0) {
    System.out.println("No arguments were specified. Exiting.");
    return;
}

Isso demonstra a característica principal dos argumentos de linha de comando: eles permitem que os programas recebam entrada externa e flexível na inicialização.

Resumo

• String[] args contém a lista de argumentos passados na execução do programa.
• Todos os argumentos são tratados como strings.
• Mesmo quando nenhum argumento é fornecido, args não é null, mas um array vazio.
• O uso de argumentos torna os programas flexíveis, reutilizáveis e fáceis de automatizar.

No próximo capítulo, continuaremos a base apresentada e demonstraremos padrões de uso básicos e exemplos de código concretos para extrair e usar valores de args.

3. Uso Básico e Exemplos de Código

Sintaxe Básica dos Argumentos de Linha de Comando

Para usar argumentos de linha de comando, você primeiro extrai valores de String[] args, que é passado ao método main.
Como args é um array, você pode acessar cada elemento pelo seu índice.

public class CommandExample {
    public static void main(String[] args) {
        System.out.println("Number of arguments: " + args.length);
        if (args.length > 0) {
            System.out.println("First argument: " + args[0]);
        } else {
            System.out.println("No arguments were specified.");
        }
    }
}

Execute o programa da seguinte forma:

javac CommandExample.java
java CommandExample hello

Saída:

Number of arguments: 1
First argument: hello

Como mostrado acima, args[0] armazena o primeiro valor passado.
Se múltiplos argumentos forem fornecidos, eles podem ser acessados como args[1], args[2] e assim por diante.

.### Processando Todos os Argumentos de Uma Vez

Quando o número de argumentos é variável, é comum processá‑los usando um loop.
O exemplo a seguir imprime todos os argumentos recebidos sequencialmente.

public class PrintArgs {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("No arguments were provided.");
            System.out.println("Example: java PrintArgs apple orange banana");
            return;
        }

        System.out.println("Argument list:");
        for (int i = 0; i < args.length; i++) {
            System.out.printf("args[%d] = %s%n", i, args[i]);
        }
    }
}

Execução:

java PrintArgs apple orange banana

Saída:

Argument list:
args[0] = apple
args[1] = orange
args[2] = banana

Usar um loop permite que seu programa lide com qualquer quantidade de argumentos.
Como boa prática, sempre verifique o comprimento do array antes de acessar os elementos.

Atribuindo Significado com Base na Ordem dos Argumentos

Você pode atribuir significados específicos aos argumentos com base na ordem deles.
Por exemplo, considere um programa que aceita um nome de arquivo, um modo e uma bandeira de sobrescrita.

public class FileProcessor {
    public static void main(String[] args) {
        if (args.length < 3) {
            System.out.println("Usage: java FileProcessor <file> <mode> <overwrite>");
            System.out.println("Example: java FileProcessor data.txt verbose true");
            return;
        }

        String fileName = args[0];
        String mode = args[1];
        boolean overwrite = Boolean.parseBoolean(args[2]);

        System.out.println("File name: " + fileName);
        System.out.println("Mode: " + mode);
        System.out.println("Overwrite enabled: " + overwrite);
    }
}

Exemplo de execução:

java FileProcessor data.txt simple false

Saída:

File name: data.txt
Mode: simple
Overwrite enabled: false

Ao atribuir papéis às posições dos argumentos, você pode obter um controle flexível do programa.

Exemplo: Tratando Argumentos como Números

Como todos os argumentos são passados como strings, a conversão de tipo é necessária ao tratá‑los como números.
O programa a seguir recebe dois inteiros e imprime sua soma.

public class SumArgs {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Please specify two integers.");
            return;
        }

        int a = Integer.parseInt(args[0]);
        int b = Integer.parseInt(args[1]);
        int sum = a + b;

        System.out.println("Sum: " + sum);
    }
}

Execução:

java SumArgs 7 13

Saída:

Sum: 20

Se um valor não numérico, como "abc", for passado, ocorrerá uma NumberFormatException.
Para tornar seu programa mais robusto, você deve adicionar tratamento de exceções.

Implementação Segura com Tratamento de Exceções

public class SafeSum {
    public static void main(String[] args) {
        try {
            if (args.length < 2) {
                throw new IllegalArgumentException("Insufficient arguments. Please specify two integers.");
            }
            int a = Integer.parseInt(args[0]);
            int b = Integer.parseInt(args[1]);
            System.out.println("Sum: " + (a + b));
        } catch (NumberFormatException e) {
            System.out.println("One or more arguments cannot be interpreted as numbers.");
        } catch (IllegalArgumentException e) {
            System.out.println(e.getMessage());
        }
    }
}

Com o tratamento de exceções adequado, o programa pode retornar mensagens claras em vez de terminar abruptamente quando argumentos inválidos são fornecidos.

Resumo

.* Os argumentos da linha de comando são passados como strings no array args. * Sempre verifique args.length antes de acessar elementos. * Use loops para lidar com um número variável de argumentos. * Converta valores numéricos usando métodos como Integer.parseInt(). * Implemente tratamento de exceções para um comportamento mais amigável ao usuário.

No próximo capítulo, revisamos erros comuns e precauções importantes e explicamos como escrever código mais seguro e reutilizável.

4. Erros Comuns e Precauções

Embora os argumentos da linha de comando sejam um mecanismo simples, há várias armadilhas que iniciantes costumam encontrar.
Este capítulo apresenta erros típicos e contramedidas práticas para evitá‑los.

Erros de Índice de Array (ArrayIndexOutOfBoundsException)

O erro mais frequente é acessar um índice que não existe.
Como args é um array, especificar um índice fora do intervalo resulta na exceção abaixo.

Exemplo: Código Incorreto

public class ErrorExample {
    public static void main(String[] args) {
        System.out.println(args[0]); // Error occurs if no arguments are provided
    }
}

Execução:

java ErrorExample

Saída:

Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 0

Contramedida

Sempre verifique args.length antes de acessar elementos do array.

if (args.length == 0) {
    System.out.println("No arguments were specified.");
    return;
}
System.out.println("First argument: " + args[0]);

Ponto chave:
args nunca é null.
Mesmo quando nenhum argumento é fornecido, ele existe como um array com comprimento 0.

Todos os Argumentos São Strings

Os argumentos da linha de comando são sempre recebidos como strings.
Portanto, a conversão de tipo é necessária para realizar cálculos numéricos.

int num = Integer.parseInt(args[0]);

Se for passada uma string não numérica, como "abc", ocorrerá um NumberFormatException.

Contramedida: Adicionar Tratamento de Exceção

try {
    int num = Integer.parseInt(args[0]);
    System.out.println("Input value: " + num);
} catch (NumberFormatException e) {
    System.out.println("The argument cannot be interpreted as a number. Please provide a valid value.");
}

Ponto chave:
Usar argumentos diretamente como números é arriscado.
Sempre presuma que a entrada fornecida pelo usuário pode ser inválida.

Argumentos Contendo Espaços

Na linha de comando, espaços são tratados como separadores de argumentos.
Para passar uma string que contém espaços, você deve envolvê‑la entre aspas duplas.

Exemplo:

java Message "Hello World"

Resultado:

args[0] = Hello World

Se o programa for executado sem aspas, "Hello" e "World" serão tratados como argumentos separados.

Manipulando Caracteres Multibyte

Ao passar caracteres multibyte, como texto não‑ASCII, podem surgir problemas de codificação de caracteres.
Em sistemas Windows, em particular, a codificação do console costuma ser MS932 (Shift_JIS), o que pode entrar em conflito com programas Java baseados em UTF‑8.

Contramedidas:

• Defina o prompt de comando para UTF‑8 antes da execução (chcp 65001).
• Unifique a codificação para UTF‑8 nas configurações de execução da IDE (Eclipse / IntelliJ IDEA).
• Especifique a opção de inicialização do Java -Dfile.encoding=UTF-8.

  java -Dfile.encoding=UTF-8 Sample Hello
  

Muitos ou Argumentos Muito Longos

Dependendo do sistema operacional, há um limite no comprimento total dos argumentos da linha de comando.
No Windows, o limite é aproximadamente 8 000 caracteres, enquanto no Linux é cerca de 128 KB.
Se precisar manipular grandes volumes de dados, use entrada por arquivo ou entrada padrão em vez de argumentos da linha de comando.

Caracteres Especiais e Escape

Em shells e prompts de comando, certos caracteres como <, > e & têm significados especiais.
Para passá‑los como argumentos literais, envolva‑os entre aspas ou escape‑os.

Exemplo:

java SymbolTest "<tag>" "&value"

Isso impede que o shell interprete erroneamente esses caracteres como operadores de redirecionamento ou pipe.

Ordem de Argumentos Incorreta

Quando a ordem dos argumentos importa, os usuários podem especificar acidentalmente valores na sequência errada.
Isso é especialmente comum com pares como nomes de arquivos de entrada e saída.

Contramedidas:

• Use opções nomeadas como --input=input.txt (abordado em capítulos posteriores).
• Forneça uma opção help que explique claramente o uso.

Resumo

No próximo capítulo, apresentamos padrões de design práticos usando conversão de tipos, formatos de opções e valores padrão para construir ferramentas de linha de comando mais robustas.

5. Uso Prático: Conversão de Tipo, Argumentos de Opção e Valores Padrão

Neste capítulo, exploramos técnicas para lidar com argumentos de linha de comando de forma mais flexível e pronta para produção.
Ao aplicar conversão de tipo, argumentos no estilo de opção e design de valores padrão, você pode criar programas que são mais seguros e mais fáceis de usar.

Convertendo Argumentos para Tipos Numéricos e Booleanos

Todos os argumentos de linha de comando são passados como valores String, mas operações aritméticas e lógica condicional requerem tipos de dados apropriados.

Convertendo para Números

int count = Integer.parseInt(args[0]);
double rate = Double.parseDouble(args[1]);

Convertendo para Booleano

boolean debugMode = Boolean.parseBoolean(args[2]);

Exemplo: Programa de Cálculo Numérico

public class Multiply {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Usage: java Multiply <number1> <number2>");
            return;
        }

        try {
            double a = Double.parseDouble(args[0]);
            double b = Double.parseDouble(args[1]);
            System.out.println("Result: " + (a * b));
        } catch (NumberFormatException e) {
            System.out.println("One or more arguments are not numeric.");
        }
    }
}

Execução:

java Multiply 4.5 3

Saída:

Result: 13.5

Pontos‑chave:

• Sempre envolva as conversões em blocos try-catch para lidar com entradas inválidas de forma segura.
• Boolean.parseBoolean() retorna true apenas quando o valor é igual a "true", ignorando maiúsculas/minúsculas.

Projetando Argumentos de Opção Nomeada

Projetos que dependem da ordem dos argumentos são propensos a erros humanos.
Usar opções nomeadas como --key=value ou flags como -v torna os programas mais intuitivos.

Exemplo: Analisando Opções Nomeadas

public class OptionParser {
    public static void main(String[] args) {
        boolean verbose = false;
        String mode = "normal";
        String file = "default.txt";

        for (String arg : args) {
            if (arg.equals("-v") || arg.equals("--verbose")) {
                verbose = true;
            } else if (arg.startsWith("--mode=")) {
                mode = arg.substring("--mode=".length());
            } else if (arg.startsWith("--file=")) {
                file = arg.substring("--file=".length());
            }
        }

        System.out.println("Mode: " + mode);
        System.out.println("File: " + file);
        System.out.println("Verbose output: " + verbose);
    }
}

Execução:

java OptionParser --mode=debug --file=log.txt -v

Saída:

Mode: debug
File: log.txt
Verbose output: true

Pontos‑chave:

• startsWith() facilita a detecção de formatos --key=value.
• Os argumentos podem ser especificados em qualquer ordem.
• Bem adequado para scripts de shell e tarefas automatizadas.

Fornecendo Valores Padrão

É importante definir valores padrão seguros caso argumentos sejam omitidos.
Isso permite que o programa seja executado com entrada mínima e evita encerramentos inesperados.

Exemplo: Programa com Valores Padrão

public class Greeting {
    public static void main(String[] args) {
        String name = "Guest";
        String lang = "ja";

.        if (args.length > 0) name = args[0];
        if (args.length > 1) lang = args[1];

        if (lang.equals("en")) {
            System.out.println("Hello, " + name + "!");
        } else if (lang.equals("fr")) {
            System.out.println("Bonjour, " + name + "!");
        } else {
            System.out.println("Hello (default), " + name + "!");
        }
    }
}

Execution:

java Greeting Taro en

Output:

Hello, Taro!

Execution without arguments:

java Greeting

Output:

Hello (default), Guest!

Key points:

• Safely handles missing arguments.
• Behavior adapts based on the number of provided arguments.

Generalizing Option Parsing

For more complex tools, creating a dedicated option parser improves maintainability compared to manually processing args.

Example: Simple Option Parser

import java.util.HashMap;

public class SimpleParser {
    public static void main(String[] args) {
        HashMap<String, String> options = new HashMap<>();

        for (String arg : args) {
            if (arg.startsWith("--") && arg.contains("=")) {
                String[] pair = arg.substring(2).split("=", 2);
                options.put(pair[0], pair[1]);
            }
        }

        System.out.println("Parsed options:");
        for (String key : options.keySet()) {
            System.out.println(key + " = " + options.get(key));
        }
    }
}

Execution:

java SimpleParser --user=admin --port=8080 --mode=test

Output:

Parsed options:
user = admin
port = 8080
mode = test

Key points:

• HashMap allows flexible storage of key-value pairs.
• The parser can serve as a reusable foundation for CLI tools.

Practical Design Patterns

• Few arguments : positional arguments are sufficient.
• Many configuration values : use named options ( --key=value ).
• Many optional values : define default values.
• System integration and scripting : adopt consistent option conventions (e.g., --help , --config ).

Summary

In the next chapter, we introduce real-world usage patterns, including file operations, batch processing, and mode switching commonly used in production environments.

6. Applied Examples: Common Real-World Patterns

This chapter demonstrates how command-line arguments are used in real-world scenarios.
By flexibly specifying arguments, you can build highly reusable tools for file operations, mode switching, and logging control.

Processing Files Specified by Command-Line Arguments

The most common use case is receiving a target file as a command-line argument.
This pattern is especially useful for automating file read/write operations.

Example: Reading and Displaying File Contents

import java.nio.file.*;
import java.io.IOException;

public class FileReaderTool {
    public static void main(String[] args) {
        if (args.length == 0) {
            System.out.println("Usage: java FileReaderTool <filePath>");
            return;
        }

        String filePath = args[0];
        try {
            String content = Files.readString(Paths.get(filePath));
            System.out.println("=== Contents of " + filePath + " ===");
            System.out.println(content);
        } catch (IOException e) {
            System.out.println("Failed to read file: " + e.getMessage());
        }
    }
}

Execution example:

java FileReaderTool data.txt

Sample output:

=== Contents of data.txt ===
Sample data line 1
Sample data line 2

Key points:

• Always include file existence checks and exception handling.
• Easy to extend for batch processing of multiple files.

Switching Program Behavior by Mode

Using arguments to switch behavior allows a single program to serve multiple roles.

Example: Mode-Based Execution

.“` public class ModeSelector { public static void main(String[] args) { if (args.length == 0) { System.out.println(“Usage: java ModeSelector “); System.out.println(“Available modes: test / prod / debug”); return; }

    String mode = args[0].toLowerCase();

    switch (mode) {
        case "test":
            System.out.println("Running in test mode...");
            break;
        case "prod":
            System.out.println("Running in production mode...");
            break;
        case "debug":
            System.out.println("Running in debug mode with detailed logging...");
            break;
        default:
            System.out.println("Unknown mode: " + mode);
    }
}

}

Execução:

java ModeSelector debug

Saída:

Running in debug mode with detailed logging…

**Pontos principais:**



* Útil para alternar entre ambientes de desenvolvimento, teste e produção.
* Amplamente usado em scripts de automação e trabalhos em lote.



### Automatizando Cálculos com Múltiplos Argumentos



No processamento em lote e em scripts agendados, os argumentos são frequentemente usados para passar parâmetros dinamicamente.  
O exemplo a seguir mostra uma ferramenta de calculadora simples que opera sobre dois valores numéricos.

public class Calculator { public static void main(String[] args) { if (args.length < 3) { System.out.println(“Usage: java Calculator “); System.out.println(“Example: java Calculator 10 5 add”); return; }

    double a = Double.parseDouble(args[0]);
    double b = Double.parseDouble(args[1]);
    String op = args[2];

    switch (op) {
        case "add": System.out.println(a + b); break;
        case "sub": System.out.println(a - b); break;
        case "mul": System.out.println(a * b); break;
        case "div":
            if (b == 0) {
                System.out.println("Division by zero is not allowed.");
            } else {
                System.out.println(a / b);
            }
            break;
        default:
            System.out.println("Unknown operation.");
    }
}

}

Execução:

java Calculator 8 2 mul

Saída:

16.0

Essa abordagem permite criar **ferramentas pequenas e amigáveis a scripts** que se integram facilmente a fluxos de trabalho de automação.



### Especificando Configuração com Argumentos de Opção



Para uma operação mais flexível, argumentos no estilo de opção, como `--key=value`, são extremamente úteis.

public class ConfigLoader { public static void main(String[] args) { String config = “default.conf”; boolean verbose = false;

    for (String arg : args) {
        if (arg.startsWith("--config=")) {
            config = arg.substring("--config=".length());
        } else if (arg.equals("--verbose")) {
            verbose = true;
        }
    }

    System.out.println("Configuration file: " + config);
    System.out.println("Verbose logging: " + (verbose ? "ON" : "OFF"));
}

}

Execução:

java ConfigLoader –config=prod.conf –verbose

Saída:

Configuration file: prod.conf Verbose logging: ON

**Pontos principais:**



* Opções nomeadas reduzem erros humanos porque a ordem não importa.
* Comumente usadas para caminhos de configuração e modos de execução.



### Exemplo Prático: Ferramenta de Processamento de Arquivos com Registro de Log

import java.nio.file.; import java.io.;

public class FileCopyTool { public static void main(String[] args) { if (args.length < 2) { System.out.println(“Usage: java FileCopyTool

[–verbose]”); return; }

    String input = args[0];
    String output = args[1];
    boolean verbose = (args.length > 2 && args[2].equals("--verbose"));

    try {
        Files.copy(Paths.get(input), Paths.get(output), StandardCopyOption.REPLACE_EXISTING);
        if (verbose) {
            System.out.println("File copied successfully: " + input + " → " + output);
        }
    } catch (IOException e) {
        System.out.println("Copy failed: " + e.getMessage());
    }
}

}

Execution:

java FileCopyTool report.txt backup.txt –verbose

Output:

File copied successfully: report.txt → backup.txt “`

Key points:

• Logging can be toggled via options for development or production use.
• This structure is reusable as a foundation for real-world scripts.

Summary

In the next chapter, we cover how to pass command-line arguments in IDEs and testing environments, including Eclipse and IntelliJ IDEA, along with debugging tips.

7. Testing and Debugging Tips / Configuring Arguments in IDEs

Programs that use command-line arguments can be executed and tested not only from the terminal, but also within development environments such as Eclipse and IntelliJ IDEA.
This chapter explains how to configure arguments during development and introduces tips for efficient debugging.

Setting Arguments in Eclipse

In Eclipse, you can configure command-line arguments using Run Configurations.
This allows you to run programs with predefined arguments without manually typing commands each time.

Steps:

1. From the menu bar, select Run → Run Configurations… .
2. From the list on the left, choose the target Java Application.
3. Open the Arguments tab.
4. Enter arguments in the Program arguments field, separated by spaces. Example: data.txt debug true
5. Click Apply , then Run .

The same arguments will be reused the next time you run the program.
You can also save multiple configurations to switch between different test scenarios.

Tips:

• Arguments may be written on separate lines; Eclipse treats them as space-separated values.
• Strings containing spaces must be enclosed in double quotation marks (e.g., "Hello World" ).
• To change character encoding, specify -Dfile.encoding=UTF-8 in the VM arguments field.

Setting Arguments in IntelliJ IDEA

IntelliJ IDEA provides an even more streamlined configuration process.

Steps:

1. Open Run → Edit Configurations… .
2. Select the configuration for the target class.
3. Enter arguments in the Program arguments field. Example: --mode=debug --file=log.txt --verbose
4. Click OK or Apply , then run the program.

Tips:

• Run configurations are saved per project.
• The same configuration is used for both Run and Debug executions.
• You can define environment variables alongside arguments to closely simulate production environments.

Understanding Differences from Command-Line Execution

There may be differences between running a program in an IDE and running it directly from the terminal, particularly regarding environment variables and working directories.

Being aware of these differences helps prevent issues that only occur after deployment.

Debugging Tips for Argument-Based Programs

• Print all received arguments at startup to verify correct input.
• Log parsed values after validation and type conversion.
• Use breakpoints at argument parsing logic to inspect runtime values.
• Test edge cases such as missing arguments, invalid values, and empty strings.

Summary

• Command-line arguments can be tested efficiently within IDEs.
• Eclipse and IntelliJ IDEA provide built-in support for argument configuration.
• Be mindful of differences between IDE and terminal environments.
• Effective debugging starts with validating and logging argument values.

Com essas técnicas, você pode desenvolver, testar e depurar programas Java que dependem de argumentos de linha de comando com confiança, garantindo um comportamento consistente entre ambientes de desenvolvimento e produção.