Arguments en ligne de commande Java expliqués : des bases aux modèles de conception pratiques

1. Introduction

Objectif de ce chapitre

Les arguments de ligne de commande Java sont une fonctionnalité fondamentale qui permet aux programmes de recevoir des valeurs externes à l’exécution et de modifier leur comportement en conséquence. Cet article explique tout, depuis la signification de String[] args jusqu’aux modèles de conception pratiques utilisés dans des applications réelles. Dans ce chapitre, nous clarifions d’abord ce que les arguments de ligne de commande peuvent faire et dans quelles situations ils sont utiles.

Qu’est‑ce que les arguments de ligne de commande ?

Une application Java démarre généralement à partir d’une méthode main avec la signature suivante :

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

args est un tableau de chaînes qui stocke les valeurs fournies lors du lancement du programme. Par exemple :

javac App.java
java App Tokyo 2025 debug

Dans ce cas, args contient ["Tokyo", "2025", "debug"].
Si aucun argument n’est fourni, args.length vaut 0.

Cas d’utilisation courants

• Changement d’environnement ou de cible : mode production vs test, codes régionaux, langues, niveaux de journalisation.
• Spécification externe des cibles de traitement : noms de fichiers d’entrée, répertoires, URL, listes d’ID.
• Traitement par lots et automatisation : passage de dates ou de plages à des jobs planifiés, injection de paramètres depuis des pipelines CI/CD.

Dans tous les cas, le comportement peut être modifié sans recompilation, ce qui rend les arguments de ligne de commande idéaux pour les scripts shell et les planificateurs de tâches comme cron.

Principaux points de conception

• Séparer les arguments obligatoires et optionnels : si des arguments obligatoires sont manquants, échouer clairement avec une aide ou des codes de sortie.
• Valider tôt : convertir les valeurs numériques ou de date dès que possible et fournir des indications claires en cas d’entrée invalide.
• Définir des valeurs par défaut : les arguments optionnels doivent avoir des valeurs sûres afin que le programme puisse tout de même s’exécuter.
• Lisibilité et maintenabilité : éviter de disperser l’accès direct au tableau ; analyser les arguments dans des objets structurés (DTO ou classes de configuration).

Choisir entre arguments, variables d’environnement et fichiers de configuration

• Arguments de ligne de commande : idéaux pour des surcharges temporaires ou des réglages spécifiques à un job (priorité la plus élevée, configuration locale).
• Variables d’environnement : adaptées aux secrets ou aux points de terminaison qui diffèrent selon l’environnement de déploiement.
• Fichiers de configuration (properties/JSON/YAML) : parfaits pour gérer de nombreux paramètres de façon systématique avec réutilisation et contrôle de version.

En pratique, une conception à trois niveaux — fichiers de configuration + variables d’environnement + arguments de ligne de commande — fonctionne bien, les arguments de ligne de commande ayant la priorité la plus élevée.

Exemple minimal : lister tous les arguments

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

Ce que cet article couvrira ensuite (feuille de route)

• Opérations de base sur String[] args (vérifications de longueur, accès aux éléments)
• Conversion de type (int/double/boolean et gestion des exceptions)
• Formats d’options tels que -v, --help et --mode=prod
• Configuration de l’IDE et comment passer des arguments lors des tests
• Gestion des erreurs et considérations de sécurité (entrée invalide, gestion des exceptions)
• Exemples pratiques (traitement de fichiers, changement de mode, contrôle du niveau de journalisation)

Tout d’abord, souvenez‑vous de ce principe de base : tous les arguments sont transmis sous forme de chaînes et doivent être convertis et validés en toute sécurité avant utilisation. Dans le chapitre suivant, nous explorerons la syntaxe de base et les modèles courants avec des exemples de code concrets.

2. Qu’est‑ce que les arguments de ligne de commande ?

La relation entre la méthode main et String[] args

Le point d’entrée d’une application Java est la méthode main, définie comme suit :

public static void main(String[] args)

Ici, args signifie « arguments » et est un tableau de chaînes qui stocke les valeurs passées de l’extérieur lors du démarrage du programme.
Lorsque vous exécutez un programme, les valeurs spécifiées après java ClassName, séparées par des espaces, sont stockées séquentiellement dans args.

Exemple : Exécution avec des arguments

javac Sample.java
java Sample apple orange banana

Dans ce cas, le contenu de args est le suivant :

En d’autres termes, args se comporte comme une liste de chaînes de longueur variable, vous permettant de passer n’importe quel nombre de valeurs.
Si aucun argument n’est spécifié, args.length devient 0 (il n’est jamais null).

Exemple d’exécution et sortie

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

Sortie :

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

Le point important ici est que tous les arguments sont reçus sous forme de chaînes.
Si vous souhaitez les utiliser comme nombres ou valeurs booléennes, vous devez les convertir explicitement ultérieurement.

Quand devez‑vous utiliser les arguments en ligne de commande ?

Les arguments en ligne de commande sont couramment utilisés dans les scénarios suivants :

• Changement de modes d’opération Exemple : java Server start vs java Server stop pour effectuer différentes actions.
• Spécification de chemins de fichiers ou de valeurs de configuration Exemple : java ReportGenerator /data/input.csv
• Passage de paramètres temporaires lors de l’exécution d’un script Exemple : dates, noms d’utilisateur, ou comme substituts légers aux variables d’environnement.

Ces cas d’utilisation améliorent la flexibilité et permettent aux programmes d’être contrôlés par des entrées externes sans recompilation.

Comportement lorsqu’aucun argument n’est fourni

La méthode main en Java inclut toujours String[] args, même lorsqu’aucun argument n’est passé.
Si le programme est exécuté sans arguments, args.length == 0, il est donc recommandé d’ajouter une vérification conditionnelle comme suit :

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

Cela illustre la caractéristique principale des arguments en ligne de commande : ils permettent aux programmes de recevoir des entrées externes et flexibles au démarrage.

Résumé

• String[] args contient la liste des arguments passés lors de l’exécution du programme.
• Tous les arguments sont traités comme des chaînes.
• Même lorsqu’aucun argument n’est fourni, args n’est pas null mais un tableau vide.
• L’utilisation des arguments rend les programmes flexibles, réutilisables et faciles à automatiser.

Dans le chapitre suivant, nous nous appuyons sur cette base et démontrons des modèles d’utilisation de base et des exemples de code concrets pour extraire et utiliser les valeurs de args.

3. Utilisation de base et exemples de code

Syntaxe de base des arguments en ligne de commande

Pour utiliser les arguments en ligne de commande, vous devez d’abord extraire les valeurs de String[] args, qui est passé à la méthode main.
Comme args est un tableau, vous pouvez accéder à chaque élément par son 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.");
        }
    }
}

Exécutez le programme comme suit :

javac CommandExample.java
java CommandExample hello

Sortie :

Number of arguments: 1
First argument: hello

Comme indiqué ci‑dessus, args[0] stocke la première valeur passée.
Si plusieurs arguments sont fournis, ils peuvent être accessibles sous la forme args[1], args[2], etc.

Traitement de tous les arguments d’un coup

Lorsque le nombre d’arguments est variable, il est courant de les traiter à l’aide d’une boucle.
L’exemple suivant affiche tous les arguments reçus séquentiellement.

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

Exécution :

java PrintArgs apple orange banana

Sortie :

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

Utiliser une boucle permet à votre programme de gérer n’importe quel nombre d’arguments.
En bonne pratique, vérifiez toujours la longueur du tableau avant d’accéder aux éléments.

Attribuer une signification en fonction de l’ordre des arguments

Vous pouvez attribuer des significations spécifiques aux arguments en fonction de leur ordre.
Par exemple, considérez un programme qui accepte un nom de fichier, un mode et un indicateur de réécriture.

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

Exemple d’exécution :

java FileProcessor data.txt simple false

Sortie :

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

En attribuant des rôles aux positions des arguments, vous pouvez obtenir un contrôle flexible du programme.

Exemple : Traiter les arguments comme des nombres

Comme tous les arguments sont transmis sous forme de chaînes, une conversion de type est nécessaire lorsqu’on les traite comme des nombres.
Le programme suivant reçoit deux entiers et affiche leur somme.

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

Exécution :

java SumArgs 7 13

Sortie :

Sum: 20

Si une valeur non numérique telle que « abc » est passée, une NumberFormatException se produira.
Pour rendre votre programme plus robuste, vous devez ajouter une gestion des exceptions.

Implémentation sécurisée avec gestion des exceptions

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

Avec une gestion appropriée des exceptions, le programme peut renvoyer des messages clairs au lieu de se terminer brutalement lorsque des arguments invalides sont fournis.

Résumé

• Les arguments de ligne de commande sont transmis sous forme de chaînes dans le tableau args.
• Vérifiez toujours args.length avant d’accéder aux éléments.
• Utilisez des boucles pour gérer un nombre variable d’arguments.
• Convertissez les valeurs numériques à l’aide de méthodes telles que Integer.parseInt().
• Mettez en œuvre la gestion des exceptions pour un comportement convivial.

Dans le chapitre suivant, nous passons en revue les erreurs courantes et les précautions importantes, et expliquons comment écrire du code plus sûr et réutilisable.

4. Erreurs courantes et précautions

Bien que les arguments de ligne de commande soient un mécanisme simple, il existe plusieurs pièges que les débutants rencontrent fréquemment.
Ce chapitre présente les erreurs typiques et des contre‑mesures pratiques pour les éviter.

Erreurs d’index de tableau (ArrayIndexOutOfBoundsException)

L’erreur la plus fréquente consiste à accéder à un indice qui n’existe pas.
Comme args est un tableau, spécifier un indice hors limites entraîne l’exception suivante.

Exemple : code incorrect

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

Exécution :

java ErrorExample

Sortie :

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

Contre‑mesure

Vérifiez toujours args.length avant d’accéder aux éléments du tableau.

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

Point clé :
args n’est jamais null.
Même lorsqu’aucun argument n’est fourni, il existe sous forme de tableau de longueur 0.

Tous les arguments sont des chaînes

Les arguments de ligne de commande sont toujours reçus sous forme de chaînes.
Par conséquent, une conversion de type est nécessaire pour effectuer des calculs numériques.

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

Si une chaîne non numérique comme "abc" est passée, une NumberFormatException se produira.

Contre‑mesure : ajouter la gestion des exceptions

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

Point clé :
Utiliser directement les arguments comme nombres est risqué.
Supposez toujours que les entrées fournies par l’utilisateur peuvent être invalides.

Arguments contenant des espaces

En ligne de commande, les espaces sont traités comme séparateurs d’arguments.
Pour transmettre une chaîne contenant des espaces, vous devez la placer entre guillemets doubles.

Exemple :

java Message "Hello World"

Résultat :

args[0] = Hello World

Si le programme est exécuté sans guillemets, "Hello" et "World" sont traités comme des arguments séparés.

Gestion des caractères multioctets

Lors du passage de caractères multioctets comme du texte non ASCII, des problèmes d’encodage de caractères peuvent survenir.
Sur les systèmes Windows en particulier, l’encodage de la console est souvent MS932 (Shift_JIS), ce qui peut entrer en conflit avec les programmes Java basés sur UTF-8.

Contre‑mesures :

• Configurez l’invite de commande en UTF-8 avant l’exécution (chcp 65001).
• Unifiez l’encodage en UTF-8 dans les configurations d’exécution de l’IDE (Eclipse / IntelliJ IDEA).
• Spécifiez l’option de démarrage Java -Dfile.encoding=UTF-8 .

  java -Dfile.encoding=UTF-8 Sample Hello
  

Trop d’arguments ou arguments trop longs

Selon le système d’exploitation, il existe une limite sur la longueur totale des arguments de ligne de commande.
Sur Windows, la limite est d’environ 8 000 caractères, tandis que sous Linux elle est d’environ 128 KB.
Si vous devez gérer de grandes quantités de données, utilisez l’entrée de fichier ou l’entrée standard au lieu des arguments de ligne de commande.

Caractères spéciaux et échappement

Dans les shells et les invites de commande, certains caractères comme <, > et & ont des significations spéciales.
Pour les transmettre en tant qu’arguments littéraux, placez-les entre guillemets ou échappez‑les.

Exemple :

java SymbolTest "<tag>" "&value"

Cela empêche le shell d’interpréter ces caractères comme des opérateurs de redirection ou de pipe.

Ordre d’arguments incorrect

Lorsque l’ordre des arguments est important, les utilisateurs peuvent accidentellement spécifier des valeurs dans le mauvais ordre.
C’est particulièrement fréquent avec des paires telles que les noms de fichiers d’entrée et de sortie.

Contremesures :

• Utilisez des options nommées comme --input=input.txt (décrit dans les chapitres suivants).
• Fournissez une option help qui explique clairement l’utilisation.

Résumé

Dans le chapitre suivant, nous présentons des modèles de conception pratiques utilisant la conversion de type, les formats d’options et les valeurs par défaut pour créer des outils en ligne de commande plus robustes.

5. Utilisation pratique : conversion de type, arguments d’option et valeurs par défaut

Dans ce chapitre, nous explorons des techniques pour gérer les arguments en ligne de commande de manière plus flexible et prête pour la production.
En appliquant la conversion de type, les arguments de type option et la conception de valeurs par défaut, vous pouvez créer des programmes plus sûrs et plus faciles à utiliser.

Conversion des arguments en types numériques et booléens

Tous les arguments en ligne de commande sont transmis sous forme de valeurs String, mais les opérations arithmétiques et la logique conditionnelle nécessitent des types de données appropriés.

Conversion en nombres

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

Conversion en booléen

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

Exemple : programme de calcul numérique

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

Exécution :

java Multiply 4.5 3

Sortie :

Result: 13.5

Points clés :

• Enveloppez toujours les conversions dans des blocs try-catch pour gérer les entrées invalides en toute sécurité.
• Boolean.parseBoolean() renvoie true uniquement lorsque la valeur est égale à « true », sans tenir compte de la casse.

Conception d’arguments d’option nommés

Les conceptions qui reposent sur l’ordre des arguments sont sujettes aux erreurs humaines.
L’utilisation d’options nommées comme --key=value ou d’indicateurs comme -v rend les programmes plus intuitifs.

Exemple : analyse des options nommées

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

Exécution :

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

Sortie :

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

Points clés :

• startsWith() facilite la détection des formats --key=value.
• Les arguments peuvent être spécifiés dans n’importe quel ordre.
• Bien adapté aux scripts shell et aux tâches automatisées.

Fourniture de valeurs par défaut

Il est important de définir des valeurs par défaut sûres au cas où des arguments seraient omis.
Cela permet au programme de s’exécuter avec un minimum d’entrées et empêche une terminaison inattendue.

Exemple : programme avec valeurs par défaut

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("Bonjour (par défaut), " + name + "!");
        }
    }
}

Execution:

java Greeting Taro en

Output:

Hello, Taro!

Execution without arguments:

java Greeting

Output:

Bonjour (par défaut), 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("Options analysées :");
        for (String key : options.keySet()) {
            System.out.println(key + " = " + options.get(key));
        }
    }
}

Execution:

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

Output:

Options analysées :
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("Utilisation : java FileReaderTool <filePath>");
            return;
        }

        String filePath = args[0];
        try {
            String content = Files.readString(Paths.get(filePath));
            System.out.println("=== Contenu de " + filePath + " ===");
            System.out.println(content);
        } catch (IOException e) {
            System.out.println("Échec de lecture du fichier : " + e.getMessage());
        }
    }
}

Execution example:

java FileReaderTool data.txt

Sample output:

=== Contenu de data.txt ===
Ligne de données d'exemple 1
Ligne de données d'exemple 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);
        }
    }
}

Exécution :

java ModeSelector debug

Sortie :

Running in debug mode with detailed logging...

Points clés :

• Utile pour basculer entre les environnements de développement, de test et de production.
• Largement utilisé dans les scripts d’automatisation et les travaux batch.

Automatiser les calculs avec plusieurs arguments

Dans le traitement par lots et les scripts planifiés, les arguments sont souvent utilisés pour transmettre des paramètres de manière dynamique.
L’exemple suivant montre un outil de calculateur simple qui fonctionne sur deux valeurs numériques.

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

Exécution :

java Calculator 8 2 mul

Sortie :

16.0

Cette approche vous permet de créer des outils petits et conviviaux pour les scripts qui s’intègrent facilement aux flux de travail d’automatisation.

Spécifier la configuration avec des arguments d’option

Pour une opération plus flexible, les arguments de type option tels que --key=value sont extrêmement utiles.

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

Exécution :

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

Sortie :

Configuration file: prod.conf
Verbose logging: ON

Points clés :

• Les options nommées réduisent les erreurs humaines car l’ordre n’a pas d’importance.
• Couramment utilisées pour les chemins de configuration et les modes d’exécution.

Exemple pratique : Outil de traitement de fichiers avec journalisation

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 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.

Avec ces techniques, vous pouvez développer, tester et déboguer en toute confiance des programmes Java qui s’appuient sur des arguments en ligne de commande, en assurant un comportement cohérent entre les environnements de développement et de production.