Argomenti da riga di comando Java spiegati: dalle basi ai pattern di progettazione pratici

1. Introduzione

Scopo di questo capitolo

Gli argomenti da riga di comando in Java sono una funzionalità fondamentale che consente ai programmi di ricevere valori esterni a runtime e di modificare il loro comportamento di conseguenza. Questo articolo spiega tutto, dal significato di String[] args ai pattern di progettazione pratici usati in applicazioni reali. In questo capitolo, prima chiariamo cosa possono fare gli argomenti da riga di comando e in quali situazioni sono utili.

Cosa sono gli argomenti da riga di comando?

Un’applicazione Java tipicamente inizia da un metodo main con la seguente firma:

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

args è un array di stringhe che memorizza i valori forniti al momento dell’avvio del programma. Per esempio:

javac App.java
java App Tokyo 2025 debug

In questo caso, args contiene ["Tokyo", "2025", "debug"].
Se non vengono forniti argomenti, args.length è 0.

Casi d’uso comuni

• Passare da ambienti o target : modalità produzione vs test, codici regione, lingue, livelli di log.
• Specificare target di elaborazione esternamente : nomi di file di input, directory, URL, elenchi di ID.
• Elaborazione batch e automazione : passare date o intervalli a lavori programmati, iniettare parametri da pipeline CI/CD.

In tutti i casi, il comportamento può essere modificato senza ricompilare, rendendo gli argomenti da riga di comando ideali per l’uso con script shell e scheduler di job come cron.

Considerazioni chiave di progettazione

• Separare argomenti obbligatori e opzionali : se mancano argomenti obbligatori, fallire in modo chiaro con output di aiuto o codici di uscita.
• Validare presto : convertire valori numerici o di data il prima possibile e fornire indicazioni chiare su input non validi.
• Progettare valori di default : gli argomenti opzionali dovrebbero avere valori predefiniti sicuri così il programma può comunque funzionare.
• Leggibilità e manutenibilità : evitare di spargere accessi diretti all’array; analizzare gli argomenti in oggetti strutturati (DTO o classi di configurazione).

Scegliere tra argomenti, variabili d’ambiente e file di configurazione

• Argomenti da riga di comando : migliori per sovrascritture temporanee o impostazioni specifiche per job (massima priorità, configurazione localizzata).
• Variabili d’ambiente : adatte per segreti o endpoint che differiscono per ambiente di distribuzione.
• File di configurazione (properties/JSON/YAML) : ideali per gestire più impostazioni in modo sistematico con riuso e controllo di versione.

In pratica, un design a tre livelli—file di configurazione + variabili d’ambiente + argomenti da riga di comando—funziona bene, con gli argomenti da riga di comando che hanno la massima precedenza.

Esempio minimo: elencare tutti gli argomenti

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

Cosa copre il prossimo articolo (roadmap)

• Operazioni di base su String[] args (controlli di lunghezza, accesso agli elementi)
• Conversione di tipo (int/double/boolean e gestione delle eccezioni)
• Formati di opzione come -v, --help e --mode=prod
• Configurazione IDE e come passare argomenti durante i test
• Gestione degli errori e considerazioni di sicurezza (input non valido, gestione delle eccezioni)
• Esempi pratici (elaborazione file, cambio modalità, controllo livello di log)

Prima di tutto, ricordate questo principio fondamentale: tutti gli argomenti vengono passati come stringhe e devono essere convertiti e validati in modo sicuro prima dell’uso. Nel capitolo successivo, esploreremo la sintassi di base e i pattern comuni con esempi di codice concreti.

2. Cosa sono gli argomenti da riga di comando?

La relazione tra il metodo main e String[] args

Il punto di ingresso di un’applicazione Java è il metodo main, definito come segue:

public static void main(String[] args)

Qui, args sta per “argomenti” ed è un array di stringhe che memorizza i valori passati dall’esterno quando il programma avvia.
Quando esegui un programma, i valori specificati dopo java ClassName, separati da spazi, vengono memorizzati sequenzialmente in args.

Esempio: Esecuzione con argomenti

javac Sample.java
java Sample apple orange banana

In questo caso, il contenuto di args è il seguente:

In altre parole, args si comporta come una lista di stringhe a lunghezza variabile, consentendo di passare un numero qualsiasi di valori.
Se non vengono specificati argomenti, args.length diventa 0 (non è mai null).

Esempio di esecuzione e output

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

Output:

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

Il punto importante qui è che tutti gli argomenti vengono ricevuti come stringhe.
Se vuoi usarli come numeri o valori booleani, devi convertirli esplicitamente in seguito.

Quando dovresti usare gli argomenti da riga di comando?

Gli argomenti da riga di comando sono comunemente usati nei seguenti scenari:

• Cambiare modalità operative Esempio: java Server start vs java Server stop per eseguire azioni diverse.
• Specificare percorsi di file o valori di configurazione Esempio: java ReportGenerator /data/input.csv
• Passare parametri temporanei durante l’esecuzione di script Esempio: date, nomi utente, o come sostituti leggeri delle variabili d’ambiente.

Questi casi d’uso migliorano la flessibilità e consentono ai programmi di essere controllati da input esterno senza ricompilare.

Comportamento quando non vengono forniti argomenti

Il metodo main in Java include sempre String[] args, anche quando non vengono passati argomenti.
Se il programma viene eseguito senza argomenti, args.length == 0, quindi è consigliato aggiungere un controllo condizionale come il seguente:

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

Ciò dimostra la caratteristica chiave degli argomenti da riga di comando: consentono ai programmi di ricevere input flessibili ed esterni all’avvio.

Riepilogo

• String[] args contiene la lista degli argomenti passati all’esecuzione del programma.
• Tutti gli argomenti sono gestiti come stringhe .
• Anche quando non vengono forniti argomenti, args non è null ma un array vuoto.
• L’uso degli argomenti rende i programmi flessibili, riutilizzabili e facili da automatizzare .

Nel capitolo successivo, costruiremo su questa base e dimostreremo modelli di utilizzo di base ed esempi di codice concreti per estrarre e utilizzare i valori da args.

3. Uso di base ed esempi di codice

Sintassi di base degli argomenti da riga di comando

Per usare gli argomenti da riga di comando, prima estrai i valori da String[] args, che viene passato al metodo main.
Poiché args è un array, puoi accedere a ciascun elemento tramite il suo indice.

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

Esegui il programma come segue:

javac CommandExample.java
java CommandExample hello

Output:

Number of arguments: 1
First argument: hello

Come mostrato sopra, args[0] memorizza il primo valore passato.
Se vengono forniti più argomenti, possono essere accessi come args[1], args[2], e così via.

Elaborazione di tutti gli argomenti in una volta

Quando il numero di argomenti è variabile, è comune elaborarli usando un ciclo.
L’esempio seguente stampa tutti gli argomenti ricevuti in sequenza.

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

Esecuzione:

java PrintArgs apple orange banana

Output:

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

Usare un ciclo consente al programma di gestire qualsiasi numero di argomenti.
Come buona pratica, controlla sempre la lunghezza dell’array prima di accedere agli elementi.

Assegnazione di significato in base all’ordine degli argomenti

Puoi assegnare significati specifici agli argomenti in base al loro ordine.
Ad esempio, considera un programma che accetta un nome file, una modalità e un flag di sovrascrittura.

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

Esempio di esecuzione:

java FileProcessor data.txt simple false

Output:

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

Assegnando ruoli alle posizioni degli argomenti, puoi ottenere un controllo flessibile del programma.

Esempio: Trattare gli argomenti come numeri

Poiché tutti gli argomenti sono passati come stringhe, è necessaria la conversione di tipo quando li tratti come numeri.
Il programma seguente riceve due interi e stampa la loro somma.

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

Esecuzione:

java SumArgs 7 13

Output:

Sum: 20

Se viene passato un valore non numerico come "abc", si verificherà una NumberFormatException.
Per rendere il tuo programma più robusto, dovresti aggiungere la gestione delle eccezioni.

Implementazione sicura con gestione delle eccezioni

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 una corretta gestione delle eccezioni, il programma può restituire messaggi chiari invece di terminare bruscamente quando vengono forniti argomenti non validi.

Riepilogo

• Gli argomenti della riga di comando vengono passati come stringhe nell’array args.
• Controlla sempre args.length prima di accedere agli elementi.
• Usa i cicli per gestire un numero variabile di argomenti.
• Converte i valori numerici usando metodi come Integer.parseInt().
• Implementa la gestione delle eccezioni per un comportamento più user‑friendly.

Nel capitolo successivo, esamineremo errori comuni e precauzioni importanti, e spiegheremo come scrivere codice più sicuro e riutilizzabile.

4. Errori comuni e precauzioni

Sebbene gli argomenti della riga di comando siano un meccanismo semplice, esistono diversi ostacoli che i principianti incontrano spesso.
Questo capitolo presenta gli errori tipici e le contromisure pratiche per prevenirli.

Errori di indice dell’array (ArrayIndexOutOfBoundsException)

L’errore più frequente è accedere a un indice che non esiste.
Poiché args è un array, specificare un indice fuori dall’intervallo genera la seguente eccezione.

Esempio: codice errato

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

Esecuzione:

java ErrorExample

Output:

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

Contromisura

Controlla sempre args.length prima di accedere agli elementi dell’array.

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

Punto chiave:
args non è mai null.
Anche quando non vengono forniti argomenti, esiste come un array di lunghezza 0.

Tutti gli argomenti sono stringhe

Gli argomenti della riga di comando sono sempre ricevuti come stringhe.
Pertanto, è necessaria la conversione di tipo per eseguire calcoli numerici.

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

Se viene passata una stringa non numerica, ad esempio "abc", si verificherà una NumberFormatException.

Contromisura: aggiungere la gestione delle eccezioni

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 chiave:
Usare gli argomenti direttamente come numeri è rischioso.
Assumi sempre che l’input fornito dall’utente possa essere non valido.

Argomenti contenenti spazi

Nella riga di comando, gli spazi sono trattati come separatori di argomenti.
Per passare una stringa che contiene spazi, devi racchiuderla tra virgolette doppie.

Esempio:

java Message "Hello World"

Risultato:

args[0] = Hello World

Se il programma viene eseguito senza virgolette, "Hello" e "World" sono trattati come argomenti separati.

Gestione dei caratteri multibyte

Quando si passano caratteri multibyte, come testo non ASCII, possono verificarsi problemi di codifica dei caratteri.
Sui sistemi Windows, in particolare, la codifica della console è spesso MS932 (Shift_JIS), che può entrare in conflitto con i programmi Java basati su UTF-8.

Contromisure:

• Imposta il prompt dei comandi su UTF-8 prima dell’esecuzione (chcp 65001).
• Uniforma la codifica a UTF-8 nelle configurazioni di esecuzione dell’IDE (Eclipse / IntelliJ IDEA).
• Specifica l’opzione di avvio di Java -Dfile.encoding=UTF-8.

  java -Dfile.encoding=UTF-8 Sample Hello
  

Troppi o argomenti troppo lunghi

A seconda del sistema operativo, esiste un limite alla lunghezza totale degli argomenti della riga di comando.
Su Windows, il limite è circa 8.000 caratteri, mentre su Linux è intorno a 128 KB.
Se devi gestire grandi quantità di dati, utilizza l’input da file o lo standard input invece degli argomenti della riga di comando.

Caratteri speciali e escape

Nelle shell e nei prompt dei comandi, alcuni caratteri come <, >, e & hanno significati speciali.
Per passarli come argomenti letterali, racchiudili tra virgolette o esegui l’escape.

Esempio:

java SymbolTest "<tag>" "&value"

Questo impedisce alla shell di interpretare erroneamente questi caratteri come operatori di reindirizzamento o pipe.

Ordine Errato degli Argomenti

Quando l’ordine degli argomenti è importante, gli utenti possono specificare accidentalmente i valori nell’ordine sbagliato.
Questo è particolarmente comune con coppie come i nomi dei file di input e output.

Contromisure:

• Usa opzioni nominate come --input=input.txt (trattate nei capitoli successivi).
• Fornisci un’opzione help che spieghi chiaramente l’uso.

Riepilogo

Nel capitolo successivo, introduciamo modelli di progettazione pratici usando la conversione di tipo, i formati delle opzioni e i valori predefiniti per costruire strumenti da riga di comando più robusti.

5. Uso Pratico: Conversione di Tipo, Argomenti Opzione e Valori Predefiniti

In questo capitolo, esploriamo tecniche per gestire gli argomenti da riga di comando in modo più flessibile e pronto per la produzione.
Applicando conversione di tipo, argomenti in stile opzione e progettazione di valori predefiniti, puoi creare programmi più sicuri e più facili da usare.

Conversione degli Argomenti in Tipi Numerici e Booleani

Tutti gli argomenti da riga di comando sono passati come valori String, ma le operazioni aritmetiche e la logica condizionale richiedono tipi di dati appropriati.

Conversione in Numeri

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

Conversione in Booleano

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

Esempio: Programma di Calcolo Numerico

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

Esecuzione:

java Multiply 4.5 3

Output:

Result: 13.5

Punti chiave:

• Avvolgi sempre le conversioni in blocchi try-catch per gestire in modo sicuro gli input non validi.
• Boolean.parseBoolean() restituisce true solo quando il valore è uguale a "true", ignorando il maiuscolo/minuscolo.

Progettazione di Argomenti Opzione Nominati

I progetti che si basano sull’ordine degli argomenti sono soggetti a errori umani.
Usare opzioni nominate come --key=value o flag come -v rende i programmi più intuitivi.

Esempio: Analisi delle Opzioni Nominati

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

Esecuzione:

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

Output:

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

Punti chiave:

• startsWith() rende facile rilevare i formati --key=value.
• Gli argomenti possono essere specificati in qualsiasi ordine.
• Ideale per script shell e lavori automatizzati.

Fornitura di Valori Predefiniti

È importante definire valori predefiniti sicuri nel caso in cui gli argomenti vengano omessi.
Ciò consente al programma di funzionare con input minimo e previene terminazioni inaspettate.

Esempio: Programma con Valori Predefiniti

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

Esecuzione:

java ModeSelector debug

Output:

Running in debug mode with detailed logging...

Punti chiave:

• Utile per passare tra ambienti di sviluppo, test e produzione.
• Ampiamente usato in script di automazione e lavori batch.

Automatizzare i Calcoli con Argomenti Multipli

Nell’elaborazione batch e negli script programmati, gli argomenti sono spesso usati per passare parametri in modo dinamico.
Il seguente esempio mostra un semplice strumento calcolatore che opera su due valori numerici.

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

Esecuzione:

java Calculator 8 2 mul

Output:

16.0

Questo approccio consente di creare strumenti piccoli e adatti agli script che si integrano facilmente nei flussi di lavoro di automazione.

Specificare la Configurazione con Argomenti Opzione

Per un’operazione più flessibile, gli argomenti in stile opzione come --key=value sono estremamente utili.

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

Esecuzione:

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

Output:

Configuration file: prod.conf
Verbose logging: ON

Punti chiave:

• Le opzioni nominate riducono gli errori umani perché l’ordine non è importante.
• Comunemente usate per percorsi di configurazione e modalità di esecuzione.

Esempio Pratico: Strumento di Elaborazione File con Logging

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("File copiato con successo: " + input + " → " + output);
            }
        } catch (IOException e) {
            System.out.println("Copia fallita: " + e.getMessage());
        }
    }
}

Execution:

java FileCopyTool report.txt backup.txt --verbose

Output:

File copiato con successo: 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 queste tecniche, puoi sviluppare, testare e fare il debug con fiducia di programmi Java che si basano su argomenti da linea di comando, garantendo un comportamento coerente tra ambienti di sviluppo e di produzione.