Argumentos de línea de comandos en Java explicados: de lo básico a los patrones de diseño prácticos

.## 1. Introducción

Propósito de este capítulo

Los argumentos de línea de comandos en Java son una característica fundamental que permite a los programas recibir valores externos en tiempo de ejecución y modificar su comportamiento en consecuencia. Este artículo explica todo, desde el significado de String[] args hasta los patrones de diseño prácticos utilizados en aplicaciones del mundo real. En este capítulo, primero aclaramos qué pueden hacer los argumentos de línea de comandos y en qué situaciones son útiles.

¿Qué son los argumentos de línea de comandos?

Una aplicación Java normalmente se inicia a partir de un método main con la siguiente firma:

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

args es un arreglo de cadenas que almacena los valores proporcionados al lanzar el programa. Por ejemplo:

javac App.java
java App Tokyo 2025 debug

En este caso, args contiene ["Tokyo", "2025", "debug"].
Si no se proporcionan argumentos, args.length es 0.

Casos de uso comunes

• Cambiar entornos o destinos: modo producción vs pruebas, códigos de región, idiomas, niveles de registro.
• Especificar objetivos de procesamiento externamente: nombres de archivos de entrada, directorios, URLs, listas de IDs.
• Procesamiento por lotes y automatización: pasar fechas o rangos a trabajos programados, inyectar parámetros desde pipelines CI/CD.

En todos los casos, el comportamiento puede modificarse sin recompilar, lo que hace que los argumentos de línea de comandos sean ideales para usar con scripts de shell y programadores de tareas como cron.

Consideraciones clave de diseño

• Separar argumentos obligatorios y opcionales: si faltan argumentos obligatorios, fallar de forma clara con salida de ayuda o códigos de salida.
• Validar temprano: convertir valores numéricos o de fecha lo antes posible y proporcionar indicaciones claras sobre entradas inválidas.
• Diseñar valores predeterminados: los argumentos opcionales deben tener valores seguros por defecto para que el programa pueda ejecutarse aun sin ellos.
• Legibilidad y mantenibilidad: evitar el acceso directo disperso al arreglo; parsear los argumentos a objetos estructurados (DTOs o clases de configuración).

Elegir entre argumentos, variables de entorno y archivos de configuración

• Argumentos de línea de comandos: los mejores para sobrescrituras temporales o configuraciones específicas de un trabajo (máxima prioridad, configuración localizada).
• Variables de entorno: adecuadas para secretos o puntos finales que difieren según el entorno de despliegue.
• Archivos de configuración (properties/JSON/YAML): ideales para gestionar múltiples ajustes de forma sistemática, con reutilización y control de versiones.

En la práctica, un diseño de tres capas —archivos de configuración + variables de entorno + argumentos de línea de comandos— funciona bien, con los argumentos de línea de comandos teniendo la mayor precedencia.

Ejemplo mínimo: listar todos los 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]);
        }
    }
}

Qué cubre este artículo a continuación (hoja de ruta)

• Operaciones básicas sobre String[] args (comprobaciones de longitud, acceso a elementos)
• Conversión de tipos (int/double/boolean y manejo de excepciones)
• Formatos de opciones como -v, --help y --mode=prod
• Configuración del IDE y cómo pasar argumentos durante las pruebas
• Manejo de errores y consideraciones de seguridad (entrada inválida, gestión de excepciones)
• Ejemplos prácticos (procesamiento de archivos, cambio de modo, control de nivel de registro)

Primero, recuerde este principio básico: todos los argumentos se pasan como cadenas y deben convertirse y validarse de forma segura antes de usarse. En el próximo capítulo, exploraremos la sintaxis básica y los patrones comunes con ejemplos de código concretos.

2. ¿Qué son los argumentos de línea de comandos?

La relación entre el método main y String[] args

El punto de entrada de una aplicación Java es el método main, definido de la siguiente manera:

public static void main(String[] args)

Aquí, args representa “argumentos” y es un arreglo de cadenas que almacena los valores pasados desde fuera cuando se inicia el programa.
Cuando ejecutas un programa, los valores especificados después de java ClassName, separados por espacios, se almacenan secuencialmente en args.

Ejemplo: Ejecutar con argumentos

javac Sample.java
java Sample apple orange banana

En este caso, el contenido de args es el siguiente:

En otras palabras, args se comporta como una lista de cadenas de longitud variable, lo que permite pasar cualquier número de valores.
Si no se especifican argumentos, args.length pasa a ser 0 (nunca es null).

Ejemplo de ejecución y salida

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

Salida:

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

El punto importante aquí es que todos los argumentos se reciben como cadenas.
Si deseas utilizarlos como números o valores booleanos, debes convertirlos explícitamente más adelante.

¿Cuándo deberías usar argumentos de línea de comandos?

Los argumentos de línea de comandos se utilizan habitualmente en los siguientes escenarios:

• Cambiar modos de operación Ejemplo: java Server start vs java Server stop para realizar acciones diferentes.
• Especificar rutas de archivos o valores de configuración Ejemplo: java ReportGenerator /data/input.csv
• Pasar parámetros temporales durante la ejecución de scripts Ejemplo: fechas, nombres de usuario, o como sustitutos ligeros de variables de entorno.

Estos casos de uso mejoran la flexibilidad y permiten que los programas sean controlados por entrada externa sin necesidad de recompilar.

Comportamiento cuando no se proporcionan argumentos

El método main en Java siempre incluye String[] args, incluso cuando no se pasan argumentos.
Si el programa se ejecuta sin argumentos, args.length == 0, por lo que se recomienda añadir una verificación condicional como la siguiente:

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

Esto demuestra la característica clave de los argumentos de línea de comandos: permiten que los programas reciban entrada externa y flexible al iniciarse.

Resumen

• String[] args contiene la lista de argumentos pasados en la ejecución del programa.
• Todos los argumentos se manejan como cadenas.
• Incluso cuando no se proporcionan argumentos, args no es null, sino un arreglo vacío.
• El uso de argumentos hace que los programas sean flexibles, reutilizables y fáciles de automatizar.

En el próximo capítulo, continuaremos sobre esta base y demostraremos patrones de uso básicos y ejemplos de código concretos para extraer y utilizar valores de args.

3. Uso básico y ejemplos de código

Sintaxis básica de los argumentos de línea de comandos

Para usar argumentos de línea de comandos, primero extraes los valores de String[] args, que se pasa al método main.
Como args es un arreglo, puedes acceder a cada elemento mediante su í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.");
        }
    }
}

Ejecuta el programa de la siguiente manera:

javac CommandExample.java
java CommandExample hello

Salida:

Number of arguments: 1
First argument: hello

Como se muestra arriba, args[0] almacena el primer valor pasado.
Si se proporcionan varios argumentos, pueden accederse como args[1], args[2], y así sucesivamente.

Procesar Todos los Argumentos a la Vez

Cuando el número de argumentos es variable, es común procesarlos mediante un bucle.
El siguiente ejemplo imprime todos los argumentos recibidos de forma secuencial.

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

Ejecución:

java PrintArgs apple orange banana

Salida:

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

Usar un bucle permite que tu programa maneje cualquier cantidad de argumentos.
Como buena práctica, siempre verifica la longitud del arreglo antes de acceder a sus elementos.

Asignar Significado Según el Orden de los Argumentos

Puedes asignar significados específicos a los argumentos según su posición.
Por ejemplo, considera un programa que acepta un nombre de archivo, un modo y una bandera de sobrescritura.

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);
    }
}

Ejemplo de ejecución:

java FileProcessor data.txt simple false

Salida:

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

Al asignar roles a las posiciones de los argumentos, puedes lograr un control flexible del programa.

Ejemplo: Tratar los Argumentos como Números

Dado que todos los argumentos se pasan como cadenas, es necesario convertir el tipo cuando se los trata como números.
El siguiente programa recibe dos enteros y muestra su suma.

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);
    }
}

Ejecución:

java SumArgs 7 13

Salida:

Sum: 20

Si se pasa un valor no numérico como "abc", se producirá una NumberFormatException.
Para que tu programa sea más robusto, deberías añadir manejo de excepciones.

Implementación Segura con Manejo de Excepciones

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());
        }
    }
}

Con un manejo adecuado de excepciones, el programa puede devolver mensajes claros en lugar de terminar abruptamente cuando se proporcionan argumentos inválidos.

Resumen

• Los argumentos de línea de comandos se pasan como cadenas en el arreglo args.
• Siempre verifica args.length antes de acceder a los elementos.
• Usa bucles para manejar un número variable de argumentos.
• Convierte valores numéricos usando métodos como Integer.parseInt().
• Implementa manejo de excepciones para un comportamiento amigable al usuario.

En el próximo capítulo, revisaremos errores comunes y precauciones importantes, y explicaremos cómo escribir código más seguro y reutilizable.

4. Errores Comunes y Precauciones

Aunque los argumentos de línea de comandos son un mecanismo sencillo, existen varios escollos que los principiantes suelen encontrar.
Este capítulo presenta errores típicos y contramedidas prácticas para evitarlos.

Errores de Índice de Arreglo (ArrayIndexOutOfBoundsException)

El error más frecuente es acceder a un índice que no existe.
Como args es un arreglo, especificar un índice fuera de rango produce la siguiente excepción.

Ejemplo: Código Incorrecto

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

Ejecución:

java ErrorExample

Salida:

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

Contramedida

Siempre verifica args.length antes de acceder a los elementos del arreglo.

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

Punto clave:
args nunca es null.
Incluso cuando no se proporcionan argumentos, existe como un arreglo con longitud 0.

Todos los Argumentos Son Cadenas

Los argumentos de línea de comandos se reciben siempre como cadenas.
Por lo tanto, es necesario convertir el tipo para realizar cálculos numéricos.

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

Si se pasa una cadena no numérica como "abc", se producirá una NumberFormatException.

Contramedida: Añadir Manejo de Excepciones

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.");
}

Punto clave:
Usar los argumentos directamente como números es arriesgado.
Siempre asume que la entrada proporcionada por el usuario puede ser inválida.

Argumentos que Contienen Espacios

En la línea de comandos, los espacios se tratan como separadores de argumentos.
Para pasar una cadena que contiene espacios, debes encerrarla entre comillas dobles.

Ejemplo:

java Message "Hello World"

Resultado:

args[0] = Hello World

Si el programa se ejecuta sin comillas, "Hello" y "World" se tratan como argumentos separados.

Manejo de Caracteres Multibyte

Al pasar caracteres multibyte como texto no ASCII, pueden surgir problemas de codificación de caracteres.
En sistemas Windows, en particular, la codificación de la consola suele ser MS932 (Shift_JIS), lo que puede entrar en conflicto con programas Java basados en UTF-8.

Contramedidas:

• Configura la consola a UTF-8 antes de la ejecución (chcp 65001).
• Unifica la codificación a UTF-8 en las configuraciones de ejecución del IDE (Eclipse / IntelliJ IDEA).
• Especifica la opción de inicio de Java -Dfile.encoding=UTF-8.

  java -Dfile.encoding=UTF-8 Sample Hello
  

Demasiados o Demasiado Largos Argumentos

Dependiendo del sistema operativo, existe un límite en la longitud total de los argumentos de línea de comandos.
En Windows, el límite es aproximadamente 8 000 caracteres, mientras que en Linux es alrededor de 128 KB.
Si necesitas manejar grandes cantidades de datos, usa entrada de archivo o entrada estándar en lugar de argumentos de línea de comandos.

Caracteres Especiales y Escape

En shells y consolas, ciertos caracteres como <, > y & tienen significados especiales.
Para pasarlos como argumentos literales, encierra los caracteres entre comillas o escápalos.

Ejemplo:

java SymbolTest "<tag>" "&value"

Esto evita que el shell interprete erróneamente estos caracteres como operadores de redirección o de tubería.

Orden Incorrecto de Argumentos

Cuando el orden de los argumentos es importante, los usuarios pueden especificar accidentalmente los valores en la secuencia incorrecta.
Esto es especialmente frecuente con pares como los nombres de archivos de entrada y salida.

Medidas preventivas:

• Utiliza opciones con nombre como --input=input.txt (se trata en capítulos posteriores).
• Proporciona una opción help que explique claramente el uso.

Resumen

En el próximo capítulo, presentamos patrones de diseño prácticos usando conversión de tipos, formatos de opciones y valores predeterminados para crear herramientas de línea de comandos más robustas.

5. Uso Práctico: Conversión de Tipos, Argumentos de Opciones y Valores Predeterminados

En este capítulo, exploramos técnicas para manejar argumentos de línea de comandos de forma más flexible y preparada para producción.
Al aplicar conversión de tipos, argumentos al estilo de opciones y diseño con valores predeterminados, puedes crear programas que sean más seguros y más fáciles de usar.

Convertir Argumentos a Tipos Numéricos y Booleanos

Todos los argumentos de la línea de comandos se pasan como valores String, pero las operaciones aritméticas y la lógica condicional requieren tipos de datos apropiados.

Conversión a Números

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

Conversión a Booleano

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

Ejemplo: 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.");
        }
    }
}

Ejecución:

java Multiply 4.5 3

Salida:

Result: 13.5

Puntos clave:

• Siempre envuelve las conversiones en bloques try-catch para manejar entradas inválidas de forma segura.
• Boolean.parseBoolean() devuelve true solo cuando el valor es exactamente "true", sin importar mayúsculas o minúsculas.

Diseño de Argumentos de Opciones con Nombre

Los diseños que dependen del orden de los argumentos son propensos a errores humanos.
Utilizar opciones con nombre como --key=value o banderas como -v hace que los programas sean más intuitivos.

Ejemplo: Análisis de Opciones con Nombre

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);
    }
}

Ejecución:

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

Salida:

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

Puntos clave:

• startsWith() facilita la detección de formatos --key=value.
• Los argumentos pueden especificarse en cualquier orden.
• Ideal para scripts de shell y trabajos automatizados.

Provisión de Valores Predeterminados

Es importante definir valores predeterminados seguros en caso de que se omitan argumentos.
Esto permite que el programa se ejecute con una entrada mínima y evita terminaciones inesperadas.

Ejemplo: Programa con Valores Predeterminados

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

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

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

Execution:

java Greeting Taro en

Output:

¡Hola, Taro!

Execution without arguments:

java Greeting

Output:

¡Hola (por defecto), 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("Opciones analizadas:");
        for (String key : options.keySet()) {
            System.out.println(key + " = " + options.get(key));
        }
    }
}

Execution:

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

Output:

Opciones analizadas:
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("Uso: java FileReaderTool <filePath>");
            return;
        }

        String filePath = args[0];
        try {
            String content = Files.readString(Paths.get(filePath));
            System.out.println("=== Contenido de " + filePath + " ===");
            System.out.println(content);
        } catch (IOException e) {
            System.out.println("Error al leer el archivo: " + e.getMessage());
        }
    }
}

Execution example:

java FileReaderTool data.txt

Sample output:

=== Contenido de 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 <mode>");
            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);
        }
    }
}

Ejecución:

java ModeSelector debug

Salida:

Running in debug mode with detailed logging...

Puntos clave:

• Útil para cambiar entre entornos de desarrollo, pruebas y producción.
• Ampliamente usado en scripts de automatización y trabajos por lotes.

Automatizando cálculos con múltiples argumentos

En el procesamiento por lotes y scripts programados, los argumentos se usan frecuentemente para pasar parámetros de forma dinámica.
El siguiente ejemplo muestra una herramienta calculadora simple que opera con dos valores numéricos.

public class Calculator {
    public static void main(String[] args) {
        if (args.length < 3) {
            System.out.println("Usage: java Calculator <num1> <num2> <op>");
            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.");
        }
    }
}

Ejecución:

java Calculator 8 2 mul

Salida:

16.0

Este enfoque le permite crear herramientas pequeñas y amigables para scripts que se integran fácilmente con flujos de trabajo de automatización.

Especificando configuración con argumentos de opción

Para una operación más flexible, los argumentos de estilo opción como --key=value son extremadamente útiles.

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"));
    }
}

Ejecución:

java ConfigLoader --config=prod.conf --verbose

Salida:

Configuration file: prod.conf
Verbose logging: ON

Puntos clave:

• Las opciones nombradas reducen errores humanos porque el orden no importa.
• Comúnmente usadas para rutas de configuración y modos de ejecución.

Ejemplo práctico: herramienta de procesamiento de archivos con registro

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 <input> <output> [--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("Archivo copiado correctamente: " + input + " → " + output);
            }
        } catch (IOException e) {
            System.out.println("Falló la copia: " + e.getMessage());
        }
    }
}

Execution:

java FileCopyTool report.txt backup.txt --verbose

Output:

Archivo copiado correctamente: 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.

Con estas técnicas, puedes desarrollar, probar y depurar con confianza programas de Java que dependen de argumentos de línea de comandos, asegurando un comportamiento consistente en entornos de desarrollo y producción.