Argumenty příkazového řádku v Javě vysvětleny: od základů po praktické návrhové vzory

1. Úvod

Účel této kapitoly

Argumenty příkazového řádku v Javě jsou základní funkcí, která umožňuje programům přijímat externí hodnoty za běhu a měnit své chování podle nich. Tento článek vysvětluje vše od významu String[] args po praktické návrhové vzory používané v reálných aplikacích. V této kapitole nejprve objasníme, co argumenty příkazového řádku dokážou a v jakých situacích jsou užitečné.

Co jsou argumenty příkazového řádku?

Java aplikace typicky začíná metodou main s následujícím podpisem:

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

args je pole řetězců, které ukládá hodnoty poskytnuté při spuštění programu. Například:

javac App.java
java App Tokyo 2025 debug

V tomto případě args obsahuje ["Tokyo", "2025", "debug"].
Pokud nejsou zadány žádné argumenty, args.length je 0.

Běžné případy použití

• Přepínání prostředí nebo cílů : produkční vs testovací režim, kódy regionů, jazyky, úrovně logování.
• Externí určení cílových zpracování : názvy vstupních souborů, adresáře, URL, seznamy ID.
• Dávkové zpracování a automatizace : předávání dat nebo rozsahů naplánovaným úlohám, vkládání parametrů z CI/CD pipeline.

Ve všech případech lze chování změnit bez překladu, což činí argumenty příkazového řádku ideálními pro použití se shell skripty a plánovači úloh, jako je cron.

Klíčové návrhové úvahy

• Oddělit povinné a volitelné argumenty : pokud chybí povinné argumenty, selže jasně s výstupem nápovědy nebo návratovými kódy.
• Validovat co nejdříve : převádět číselné nebo datumové hodnoty co nejdříve a poskytnout jasné pokyny při neplatném vstupu.
• Navrhnout výchozí hodnoty : volitelné argumenty by měly mít bezpečné výchozí hodnoty, aby program mohl i nadále běžet.
• Čitelnost a udržovatelnost : vyhnout se rozptýlenému přímému přístupu k poli; parsovat argumenty do strukturovaných objektů (DTO nebo konfigurační třídy).

Výběr mezi argumenty, proměnnými prostředí a konfiguračními soubory

• Argumenty příkazového řádku : nejlepší pro dočasné přepsání nebo nastavení specifické pro úlohu (nejvyšší priorita, lokální konfigurace).
• Proměnné prostředí : vhodné pro tajné údaje nebo koncové body, které se liší podle nasazovacího prostředí.
• Konfigurační soubory (properties/JSON/YAML) : ideální pro systematické řízení více nastavení s možností opětovného použití a verzování.

V praxi funguje dobře třívrstvá architektura — konfigurační soubory + proměnné prostředí + argumenty příkazového řádku — přičemž argumenty příkazového řádku mají nejvyšší prioritu.

Minimální příklad: výpis všech argumentů

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

Co tento článek pokrývá dál (plán)

• Základní operace s String[] args (kontrola délky, přístup k prvkům)
• Převod typů (int/double/boolean a ošetření výjimek)
• Formáty voleb jako -v, --help a --mode=prod
• Konfigurace IDE a jak předávat argumenty během testování
• Zpracování chyb a bezpečnostní úvahy (neplatný vstup, správa výjimek)
• Praktické příklady (zpracování souborů, přepínání režimu, řízení úrovně logování)

Nejprve si zapamatujte tuto základní zásadu: všechny argumenty jsou předávány jako řetězce a musí být před použitím bezpečně převedeny a ověřeny. V další kapitole prozkoumáme základní syntaxi a běžné vzory s konkrétními ukázkami kódu.

2. Co jsou argumenty příkazového řádku?

Vztah mezi metodou main a String[] args

Vstupním bodem Java aplikace je metoda main, definovaná následovně:

public static void main(String[] args)

Zde args představuje „argumenty“ a je pole řetězců, které ukládá hodnoty předané zvenčí při spuštění programu.
Když spustíte program, hodnoty uvedené za java ClassName, oddělené mezerami, jsou uloženy postupně v args.

Příklad: Spuštění s argumenty

javac Sample.java
java Sample apple orange banana

V tomto případě jsou obsah args následující:

Jinými slovy, args se chová jako seznam řetězců proměnné délky, což vám umožňuje předat libovolný počet hodnot.
Pokud nejsou zadány žádné argumenty, args.length se stane 0 (nikdy není null).

Příklad provedení a výstup

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

Výstup:

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

Důležitým bodem je, že všechny argumenty jsou přijímány jako řetězce.
Pokud je chcete použít jako čísla nebo boolean hodnoty, musíte je později explicitně převést.

Kdy byste měli použít argumenty příkazové řádky?

Argumenty příkazové řádky se běžně používají v následujících situacích:

• Přepínání provozních režimů Příklad: java Server start vs java Server stop pro provedení různých akcí.
• Určování cest k souborům nebo konfiguračních hodnot Příklad: java ReportGenerator /data/input.csv
• Předávání dočasných parametrů během spouštění skriptu Příklad: data, uživatelská jména nebo jako lehké náhrady za proměnné prostředí.

Tyto případy použití zvyšují flexibilitu a umožňují programům být řízeny externím vstupem bez nutnosti překladu.

Chování, když nejsou poskytnuty žádné argumenty

Metoda main v Javě vždy obsahuje String[] args, i když nejsou předány žádné argumenty.
Pokud je program spuštěn bez argumentů, args.length == 0, proto se doporučuje přidat podmínkovou kontrolu, jako je následující:

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

Toto demonstruje klíčovou vlastnost argumentů příkazové řádky: umožňují programům přijímat flexibilní, externí vstup při spuštění.

Shrnutí

• String[] args obsahuje seznam argumentů předaných při spuštění programu.
• Všechny argumenty jsou zpracovány jako řetězce .
• I když nejsou poskytnuty žádné argumenty, args není null, ale prázdné pole.
• Používání argumentů dělá programy flexibilní, znovupoužitelné a snadno automatizovatelné .

V následující kapitole na této základně stavíme a ukážeme základní vzory použití a konkrétní příklady kódu pro získávání a používání hodnot z args.

3. Základní použití a příklady kódu

Základní syntaxe argumentů příkazové řádky

Pro použití argumentů příkazové řádky nejprve získáte hodnoty z String[] args, který je předán metodě main.
Protože args je pole, můžete přistupovat k jednotlivým prvkům podle jejich indexu.

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

Spusťte program následovně:

javac CommandExample.java
java CommandExample hello

Výstup:

Number of arguments: 1
First argument: hello

Jak je uvedeno výše, args[0] ukládá první předanou hodnotu.
Pokud je poskytnuto více argumentů, lze k nim přistupovat jako args[1], args[2] a tak dále.

Zpracování všech argumentů najednou

Když je počet argumentů proměnný, je běžné je zpracovávat pomocí smyčky.
Následující příklad vypíše všechny přijaté argumenty sekvenčně.

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

Spuštění:

java PrintArgs apple orange banana

Výstup:

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

Použití smyčky umožňuje vašemu programu zpracovávat libovolný počet argumentů.
Jako osvědčený postup vždy zkontrolujte délku pole před přístupem k prvkům.

Přiřazení významu na základě pořadí argumentů

Můžete přiřadit specifické významy argumentům na základě jejich pořadí.
Například zvažte program, který přijímá název souboru, režim a příznak přepsání.

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

Příklad spuštění:

java FileProcessor data.txt simple false

Výstup:

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

Přiřazením rolí pozicím argumentů můžete dosáhnout flexibilního ovládání programu.

Příklad: Zacházení s argumenty jako s čísly

Protože všechny argumenty jsou předány jako řetězce, je vyžadována konverze typů, když s nimi zacházíte jako s čísly.
Následující program přijme dva celá čísla a vypíše jejich součet.

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

Spuštění:

java SumArgs 7 13

Výstup:

Sum: 20

Pokud je předán nenumerický údaj, jako například "abc", dojde k chybě NumberFormatException.
Aby byl váš program robustnější, měli byste přidat zpracování výjimek.

Bezpečné implementace se zpracováním výjimek

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

S řádným zpracováním výjimek může program vrátit jasné zprávy místo náhlého ukončení, když jsou poskytnuty neplatné argumenty.

Shrnutí

• Příkazové argumenty jsou předávány jako řetězce v poli args.
• Vždy zkontrolujte args.length před přístupem k prvkům.
• Používejte smyčky pro zpracování proměnného počtu argumentů.
• Převádějte číselné hodnoty pomocí metod jako Integer.parseInt().
• Implementujte zpracování výjimek pro uživatelsky přívětivé chování.

V následující kapitole se podíváme na běžné chyby a důležité opatření, a vysvětlíme, jak psát bezpečnější a znovupoužitelný kód.

4. Běžné chyby a opatření

Ačkoli jsou příkazové argumenty jednoduchým mechanismem, existuje několik úskalí, se kterými začátečníci často narazí.
Tato kapitola představuje typické chyby a praktická opatření, která jim předcházejí.

Chyby indexu pole (ArrayIndexOutOfBoundsException)

Nejčastější chybou je přístup k indexu, který neexistuje.
Protože args je pole, zadání indexu mimo rozsah vede k následující výjimce.

Příklad: Nesprávný kód

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

Spuštění:

java ErrorExample

Výstup:

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

Protiopatření

Vždy zkontrolujte args.length před přístupem k prvkům pole.

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

Klíčový bod:
args není nikdy null.
I když nejsou poskytnuty žádné argumenty, existuje jako pole s délkou 0.

Všechny argumenty jsou řetězce

Příkazové argumenty jsou vždy přijímány jako řetězce.
Proto je nutná konverze typů pro provádění číselných výpočtů.

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

Pokud je předán nečíselný řetězec, například "abc", dojde k NumberFormatException.

Protiopatření: Přidat zpracování výjimek

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

Klíčový bod:
Používání argumentů přímo jako čísel je riskantní.
Vždy předpokládejte, že vstup od uživatele může být neplatný.

Argumenty obsahující mezery

V příkazovém řádku jsou mezery považovány za oddělovače argumentů.
Pro předání řetězce, který obsahuje mezery, musíte jej uzavřít do dvojitých uvozovek.

Příklad:

java Message "Hello World"

Výsledek:

args[0] = Hello World

Pokud je program spuštěn bez uvozovek, "Hello" a "World" jsou považovány za samostatné argumenty.

Zpracování vícebytových znaků

Při předávání vícebytových znaků, jako je ne‑ASCII text, mohou nastat problémy s kódováním znaků.
Na systémech Windows je kódování konzole často MS932 (Shift_JIS), což může být v rozporu s Java programy založenými na UTF-8.

Protiopatření:

• Nastavte příkazový řádek na UTF-8 před spuštěním ( chcp 65001 ).
• Sjednoťte kódování na UTF-8 v nastavení spouštění IDE (Eclipse / IntelliJ IDEA).
• Specifikujte spouštěcí volbu Javy -Dfile.encoding=UTF-8 .

  java -Dfile.encoding=UTF-8 Sample Hello
  

Příliš mnoho nebo příliš dlouhé argumenty

V závislosti na operačním systému existuje limit celkové délky příkazových argumentů.
Na Windows je limit přibližně 8 000 znaků, zatímco na Linuxu je to kolem 128 KB.
Pokud potřebujete zpracovat velké množství dat, použijte vstup ze souboru nebo standardní vstup místo příkazových argumentů.

Speciální znaky a escapování

V shellech a příkazových řádcích mají některé znaky, jako <, >, a &, speciální význam.
Pro předání těchto znaků jako doslovných argumentů je uzavřete do uvozovek nebo je escapujte.

Příklad:

java SymbolTest "<tag>" "&value"

Toto zabraňuje tomu, aby shell špatně interpretoval tyto znaky jako operátory přesměrování nebo roury.

Nesprávné pořadí argumentů

Když záleží na pořadí argumentů, uživatelé mohou omylem zadat hodnoty ve špatném pořadí.
To je zvláště časté u dvojic, jako jsou názvy vstupních a výstupních souborů.

Protiopatření:

• Používejte pojmenované volby jako --input=input.txt (popsáno v pozdějších kapitolách).
• Poskytněte volbu help, která jasně vysvětluje použití.

Shrnutí

V následující kapitole představíme praktické návrhové vzory pomocí konverze typů, formátů voleb a výchozích hodnot, abychom vytvořili odolnější nástroje pro příkazovou řádku.

5. Praktické použití: konverze typů, argumenty voleb a výchozí hodnoty

V této kapitole zkoumáme techniky pro zpracování argumentů příkazové řádky flexibilnějším a připraveným na produkci způsobem.
Použitím konverze typů, argumentů ve stylu voleb a návrhu výchozích hodnot můžete vytvářet programy, které jsou bezpečnější a uživatelsky přívětivější.

Převod argumentů na číselné a boolean typy

Všechny argumenty příkazové řádky jsou předávány jako hodnoty typu String, ale aritmetické operace a podmíněná logika vyžadují vhodné datové typy.

Převod na čísla

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

Převod na Boolean

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

Příklad: Program pro číselné výpočty

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

Spuštění:

java Multiply 4.5 3

Výstup:

Result: 13.5

Klíčové body:

• Vždy zabalte konverze do bloků try-catch, aby se neplatný vstup bezpečně ošetřil.
• Boolean.parseBoolean() vrací true pouze když hodnota je rovna "true", bez ohledu na velikost písmen.

Návrh pojmenovaných argumentů voleb

Návrhy, které se spoléhají na pořadí argumentů, jsou náchylné k lidským chybám.
Používání pojmenovaných voleb jako --key=value nebo příznaků jako -v činí programy intuitivnějšími.

Příklad: Parsování pojmenovaných voleb

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

Spuštění:

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

Výstup:

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

Klíčové body:

• startsWith() usnadňuje detekci formátů --key=value.
• Argumenty mohou být zadány v libovolném pořadí.
• Vhodné pro shell skripty a automatizované úlohy.

Poskytování výchozích hodnot

Je důležité definovat bezpečné výchozí hodnoty pro případ, že jsou argumenty vynechány.
To umožňuje programu běžet s minimálním vstupem a zabraňuje neočekávanému ukončení.

Příklad: Program s výchozími hodnotami

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

Spuštění:

java ModeSelector debug

Výstup:

Running in debug mode with detailed logging...

Klíčové body:

• Užitečné pro přepínání mezi vývojovým, testovacím a produkčním prostředím.
• Široce používáno v automatizačních skriptech a dávkových úlohách.

Automatizace výpočtů s více argumenty

V dávkovém zpracování a naplánovaných skriptech se argumenty často používají k dynamickému předávání parametrů.
Následující příklad ukazuje jednoduchý kalkulační nástroj, který pracuje se dvěma číselnými hodnotami.

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

Spuštění:

java Calculator 8 2 mul

Výstup:

16.0

Tento přístup vám umožní vytvořit malé, skriptově přátelské nástroje, které se snadno integrují do automatizačních pracovních toků.

Specifikace konfigurace pomocí volitelných argumentů

Pro flexibilnější provoz jsou argumenty ve stylu voleb, jako je --key=value, mimořádně užitečné.

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

Spuštění:

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

Výstup:

Configuration file: prod.conf
Verbose logging: ON

Klíčové body:

• Pojmenované volby snižují lidské chyby, protože na pořadí nezáleží.
• Často se používají pro cesty konfigurace a režimy spuštění.

Praktický příklad: Nástroj pro zpracování souborů s logováním

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.

S těmito technikami můžete s jistotou vyvíjet, testovat a ladit Java programy, které se spoléhají na argumenty příkazového řádku, a zajistit tak konzistentní chování napříč vývojovým a produkčním prostředím.