Java-Kommandozeilenargumente erklärt: Von den Grundlagen bis zu praktischen Designmustern

1. Einführung

Zweck dieses Kapitels

Java‑Kommandozeilenargumente sind ein grundlegendes Feature, das Programmen ermöglicht, zur Laufzeit externe Werte zu erhalten und ihr Verhalten entsprechend zu ändern. Dieser Artikel erklärt alles vom Sinn von String[] args bis zu praktischen Entwurfsmustern, die in realen Anwendungen verwendet werden. In diesem Kapitel klären wir zunächst, was Kommandozeilenargumente bewirken können und in welchen Situationen sie nützlich sind.

Was sind Kommandozeilenargumente?

Eine Java‑Anwendung startet typischerweise aus einer main‑Methode mit der folgenden Signatur:

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

args ist ein Array von Strings, das die beim Starten des Programms übergebenen Werte speichert. Zum Beispiel:

javac App.java
java App Tokyo 2025 debug

In diesem Fall enthält args ["Tokyo", "2025", "debug"].
Wenn keine Argumente übergeben werden, ist args.length 0.

Häufige Anwendungsfälle

• Umgebungen oder Ziele wechseln : Produktions‑ vs. Testmodus, Regions‑Codes, Sprachen, Log‑Level.
• Verarbeitungstargets extern festlegen : Eingabedateinamen, Verzeichnisse, URLs, ID‑Listen.
• Batch‑Verarbeitung und Automatisierung : Datums‑ oder Bereichsangaben an geplante Jobs übergeben, Parameter aus CI/CD‑Pipelines injizieren.

In allen Fällen kann das Verhalten ohne Neukompilierung geändert werden, was Kommandozeilenargumente ideal für den Einsatz in Shell‑Skripten und Job‑Planern wie cron macht.

Wichtige Designüberlegungen

• Erforderliche und optionale Argumente trennen : Fehlen Pflichtargumente, klar mit Hilfe‑Ausgabe oder Exit‑Codes fehlschlagen.
• Frühzeitig validieren : Numerische oder Datumswerte so schnell wie möglich umwandeln und klare Hinweise bei ungültiger Eingabe geben.
• Standardwerte festlegen : Optionale Argumente sollten sichere Vorgabewerte besitzen, damit das Programm trotzdem läuft.
• Lesbarkeit und Wartbarkeit : Direktes Zugreifen auf das Array vermeiden; Argumente in strukturierte Objekte (DTOs oder Konfigurationsklassen) parsen.

Auswahl zwischen Argumenten, Umgebungsvariablen und Konfigurationsdateien

• Kommandozeilenargumente : am besten für temporäre Overrides oder job‑spezifische Einstellungen (höchste Priorität, lokalisierte Konfiguration).
• Umgebungsvariablen : geeignet für Secrets oder Endpunkte, die je nach Deploy‑Umgebung variieren.
• Konfigurationsdateien (properties/JSON/YAML) : ideal, um viele Einstellungen systematisch zu verwalten, wiederzuverwenden und versionieren zu können.

In der Praxis funktioniert ein dreischichtiges Design — Konfigurationsdateien + Umgebungsvariablen + Kommandozeilenargumente — gut, wobei die Kommandozeilenargumente die höchste Priorität besitzen.

Minimalbeispiel: Alle Argumente auflisten

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

Was dieser Artikel als Nächstes behandelt (Roadmap)

• Grundoperationen mit String[] args (Längen‑Checks, Element‑Zugriff)
• Typumwandlung (int/double/boolean und Ausnahme‑Handling)
• Optionsformate wie -v, --help und --mode=prod
• IDE‑Konfiguration und wie man Argumente beim Testen übergibt
• Fehlerbehandlung und Sicherheitsaspekte (ungültige Eingaben, Ausnahme‑Management)
• Praktische Beispiele (Dateiverarbeitung, Moduswechsel, Log‑Level‑Steuerung)

Zunächst gilt das Kernprinzip: Alle Argumente werden als Strings übergeben und müssen sicher konvertiert und validiert werden, bevor sie verwendet werden. Im nächsten Kapitel untersuchen wir die grundlegende Syntax und gängige Muster anhand konkreter Code‑Beispiele.

2. Was sind Kommandozeilenargumente?

Die Beziehung zwischen der main-Methode und String[] args

Der Einstiegspunkt einer Java-Anwendung ist die main-Methode, die wie folgt definiert ist:

public static void main(String[] args)

Hier steht args für „arguments“ und ist ein String-Array, das Werte speichert, die von außen übergeben werden, wenn das Programm startet.
Wenn Sie ein Programm ausführen, werden die Werte, die nach java ClassName angegeben werden und durch Leerzeichen getrennt sind, sequentiell in args gespeichert.

Beispiel: Ausführen mit Argumenten

javac Sample.java
java Sample apple orange banana

In diesem Fall sind die Inhalte von args wie folgt:

Mit anderen Worten verhält sich args wie eine variabel lange Liste von Strings, die es ermöglicht, eine beliebige Anzahl von Werten zu übergeben.
Wenn keine Argumente angegeben werden, wird args.length zu 0 (es ist nie null).

Ausführungsbeispiel und Ausgabe

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

Ausgabe:

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

Der wichtige Punkt hier ist, dass alle Argumente als Strings empfangen werden.
Wenn Sie sie als Zahlen oder boolesche Werte verwenden möchten, müssen Sie sie später explizit konvertieren.

Wann sollten Sie Befehlszeilenargumente verwenden?

Befehlszeilenargumente werden häufig in den folgenden Szenarien verwendet:

• Umschalten von Betriebsmodi Beispiel: java Server start vs java Server stop, um unterschiedliche Aktionen auszuführen.
• Angeben von Dateipfaden oder Konfigurationswerten Beispiel: java ReportGenerator /data/input.csv
• Übergeben temporärer Parameter während der Skriptausführung Beispiel: Daten, Benutzernamen oder als leichte Ersatz für Umgebungsvariablen.

Diese Anwendungsfälle verbessern die Flexibilität und ermöglichen es, Programme durch externe Eingaben zu steuern, ohne neu zu kompilieren.

Verhalten, wenn keine Argumente bereitgestellt werden

Die main-Methode in Java enthält immer String[] args, auch wenn keine Argumente übergeben werden.
Wenn das Programm ohne Argumente ausgeführt wird, gilt args.length == 0, daher wird empfohlen, eine bedingte Überprüfung wie die folgende hinzuzufügen:

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

Dies demonstriert das Schlüsselmerkmal von Befehlszeilenargumenten: sie ermöglichen es Programmen, flexible, externe Eingaben beim Start zu empfangen.

Zusammenfassung

• String[] args enthält die Liste der Argumente, die bei der Programmausführung übergeben werden.
• Alle Argumente werden als Strings behandelt.
• Selbst wenn keine Argumente bereitgestellt werden, ist args nicht null, sondern ein leeres Array.
• Die Verwendung von Argumenten macht Programme flexibel, wiederverwendbar und einfach zu automatisieren .

Im nächsten Kapitel bauen wir auf dieser Grundlage auf und demonstrieren grundlegende Verwendungsweisen und konkrete Code-Beispiele für das Extrahieren und Verwenden von Werten aus args.

3. Grundlegende Nutzung und Code-Beispiele

Grundlegende Syntax von Befehlszeilenargumenten

Um Befehlszeilenargumente zu verwenden, extrahieren Sie zuerst Werte aus String[] args, das an die main-Methode übergeben wird.
Da args ein Array ist, können Sie auf jedes Element über seinen Index zugreifen.

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

Führen Sie das Programm wie folgt aus:

javac CommandExample.java
java CommandExample hello

Ausgabe:

Number of arguments: 1
First argument: hello

Wie oben gezeigt, speichert args[0] den ersten übergebenen Wert.
Wenn mehrere Argumente bereitgestellt werden, können sie als args[1], args[2] usw. zugegriffen werden.

Alle Argumente auf einmal verarbeiten

Wenn die Anzahl der Argumente variabel ist, ist es üblich, sie mit einer Schleife zu verarbeiten.
Das folgende Beispiel gibt alle empfangenen Argumente nacheinander aus.

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

Ausführung:

java PrintArgs apple orange banana

Ausgabe:

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

Die Verwendung einer Schleife ermöglicht es Ihrem Programm, eine beliebige Anzahl von Argumenten zu verarbeiten.
Als bewährte Praxis sollten Sie stets die Array‑Länge prüfen, bevor Sie auf Elemente zugreifen.

Bedeutung basierend auf der Argumentreihenfolge zuweisen

Sie können Argumenten basierend auf ihrer Reihenfolge spezifische Bedeutungen zuweisen.
Zum Beispiel ein Programm, das einen Dateinamen, einen Modus und ein Überschreib‑Flag akzeptiert.

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

Ausführungsbeispiel:

java FileProcessor data.txt simple false

Ausgabe:

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

Durch die Zuweisung von Rollen zu Argumentpositionen können Sie eine flexible Programmkontrolle erreichen.

Beispiel: Argumente als Zahlen behandeln

Da alle Argumente als Zeichenketten übergeben werden, ist bei der Behandlung als Zahlen eine Typumwandlung erforderlich.
Das folgende Programm empfängt zwei Ganzzahlen und gibt deren Summe aus.

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

Ausführung:

java SumArgs 7 13

Ausgabe:

Sum: 20

Wenn ein nicht‑numerischer Wert wie "abc" übergeben wird, tritt eine NumberFormatException auf.
Um Ihr Programm robuster zu machen, sollten Sie eine Ausnahmebehandlung hinzufügen.

Sichere Implementierung mit Ausnahmebehandlung

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

Mit einer ordnungsgemäßen Ausnahmebehandlung kann das Programm klare Meldungen zurückgeben, anstatt bei ungültigen Argumenten abrupt zu beenden.

Zusammenfassung

• Kommandozeilenargumente werden als Strings im args-Array übergeben.
• Überprüfen Sie immer args.length, bevor Sie auf Elemente zugreifen.
• Verwenden Sie Schleifen, um eine variable Anzahl von Argumenten zu handhaben.
• Konvertieren Sie numerische Werte mit Methoden wie Integer.parseInt().
• Implementieren Sie Ausnahmetreatment für benutzerfreundliches Verhalten.

Im nächsten Kapitel überprüfen wir häufige Fehler und wichtige Vorsichtsmaßnahmen und erklären, wie man sichereren und wiederverwendbareren Code schreibt.

4. Häufige Fehler und Vorsichtsmaßnahmen

Obwohl Kommandozeilenargumente ein einfacher Mechanismus sind, gibt es mehrere Fallstricke, die Anfänger häufig begegnen.
Dieses Kapitel stellt typische Fehler und praktische Gegenmaßnahmen vor, um sie zu verhindern.

Array-Indexfehler (ArrayIndexOutOfBoundsException)

Der häufigste Fehler ist der Zugriff auf einen Index, der nicht existiert.
Da args ein Array ist, führt die Angabe eines außerhalb des Bereichs liegenden Index zu der folgenden Ausnahme.

Beispiel: Falscher Code

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

Ausführung:

java ErrorExample

Ausgabe:

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

Gegenmaßnahme

Überprüfen Sie immer args.length, bevor Sie auf Array-Elemente zugreifen.

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

Wichtiger Punkt:
args ist nie null.
Selbst wenn keine Argumente angegeben werden, existiert es als Array mit Länge 0.

Alle Argumente sind Strings

Kommandozeilenargumente werden immer als Strings empfangen.
Daher ist eine Typkonvertierung erforderlich, um numerische Berechnungen durchzuführen.

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

Wenn ein nicht-numerischer String wie "abc" übergeben wird, tritt eine NumberFormatException auf.

Gegenmaßnahme: Ausnahmetreatment hinzufügen

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

Wichtiger Punkt:
Die direkte Verwendung von Argumenten als Zahlen ist riskant.
Gehen Sie immer davon aus, dass benutzereingaben ungültig sein könnten.

Argumente mit Leerzeichen

In der Kommandozeile werden Leerzeichen als Argumenttrenner behandelt.
Um einen String zu übergeben, der Leerzeichen enthält, müssen Sie ihn in doppelte Anführungszeichen setzen.

Beispiel:

java Message "Hello World"

Ergebnis:

args[0] = Hello World

Wenn das Programm ohne Anführungszeichen ausgeführt wird, werden "Hello" und "World" als separate Argumente behandelt.

Handhabung von Multibyte-Zeichen

Beim Übergeben von Multibyte-Zeichen wie nicht-ASCII-Text können Probleme mit der Zeichenkodierung auftreten.
Auf Windows-Systemen insbesondere ist die Konsolenkodierung oft MS932 (Shift_JIS), was mit UTF-8-basierten Java-Programmen kollidieren kann.

Gegenmaßnahmen:

• Setzen Sie die Eingabeaufforderung vor der Ausführung auf UTF-8 ( chcp 65001 ).
• Vereinheitlichen Sie die Kodierung auf UTF-8 in IDE-Ausführungskonfigurationen (Eclipse / IntelliJ IDEA).
• Geben Sie die Java-Startoption -Dfile.encoding=UTF-8 an.

  java -Dfile.encoding=UTF-8 Sample Hello
  

Zu viele oder zu lange Argumente

Abhängig vom Betriebssystem gibt es eine Grenze für die Gesamtlänge der Kommandozeilenargumente.
Unter Windows beträgt die Grenze etwa 8.000 Zeichen, während sie unter Linux etwa 128 KB beträgt.
Wenn Sie große Datenmengen handhaben müssen, verwenden Sie Dateieingabe oder Standardeingabe anstelle von Kommandozeilenargumenten.

Sonderzeichen und Escaping

In Shells und Eingabeaufforderungen haben bestimmte Zeichen wie <, >, und & besondere Bedeutungen.
Um sie als literale Argumente zu übergeben, setzen Sie sie in Anführungszeichen oder escapen Sie sie.

Beispiel:

java SymbolTest "<tag>" "&value"

.Dies verhindert, dass die Shell diese Zeichen als Umleitungs‑ oder Pipe‑Operatoren missinterpretiert.

Falsche Argumentreihenfolge

Wenn die Reihenfolge der Argumente wichtig ist, können Benutzer versehentlich Werte in der falschen Reihenfolge angeben.
Dies kommt besonders häufig bei Paaren wie Eingabe‑ und Ausgabedateinamen vor.

Gegenmaßnahmen:

• Verwenden Sie benannte Optionen wie --input=input.txt (in späteren Kapiteln behandelt).
• Stellen Sie eine help‑Option bereit, die die Verwendung klar erklärt.

Zusammenfassung

Im nächsten Kapitel stellen wir praktische Entwurfsmuster vor, die Typkonvertierung, Optionsformate und Standardwerte nutzen, um robustere Befehlszeilen‑Tools zu erstellen.

5. Praktische Anwendung: Typkonvertierung, Optionsargumente und Standardwerte

In diesem Kapitel untersuchen wir Techniken zum Umgang mit Befehlszeilenargumenten auf flexiblere und produktionsreife Weise.
Durch die Anwendung von Typkonvertierung, optionsartigen Argumenten und Standardwertdesign können Sie Programme erstellen, die sicherer und benutzerfreundlicher sind.

Konvertierung von Argumenten zu numerischen und booleschen Typen

Alle Befehlszeilenargumente werden als String‑Werte übergeben, aber arithmetische Operationen und bedingte Logik erfordern geeignete Datentypen.

Konvertierung zu Zahlen

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

Konvertierung zu Boolean

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

Beispiel: Numerisches Berechnungsprogramm

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

Ausführung:

java Multiply 4.5 3

Ausgabe:

Result: 13.5

Wichtige Punkte:

• Wickeln Sie Konvertierungen immer in try-catch‑Blöcke ein, um ungültige Eingaben sicher zu behandeln.
• Boolean.parseBoolean() gibt nur dann true zurück, wenn der Wert exakt "true" (unabhängig von Groß‑/Kleinschreibung) entspricht.

Entwurf benannter Optionsargumente

Entwürfe, die von der Reihenfolge der Argumente abhängen, sind anfällig für menschliche Fehler.
Die Verwendung benannter Optionen wie --key=value oder Flags wie -v macht Programme intuitiver.

Beispiel: Parsen benannter Optionen

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

Ausführung:

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

Ausgabe:

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

Wichtige Punkte:

• startsWith() erleichtert das Erkennen von --key=value‑Formaten.
• Argumente können in beliebiger Reihenfolge angegeben werden.
• Gut geeignet für Shell‑Skripte und automatisierte Jobs.

Bereitstellung von Standardwerten

Es ist wichtig, sichere Standardwerte zu definieren, falls Argumente weggelassen werden.
Damit kann das Programm mit minimalen Eingaben laufen und verhindert unerwartete Beendigungen.

Beispiel: Programm mit Standardwerten

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("Hallo, " + name + "!");
        } else if (lang.equals("fr")) {
            System.out.println("Bonjour, " + name + "!");
        } else {
            System.out.println("Hallo (Standard), " + name + "!");
        }
    }
}

Execution:

java Greeting Taro en

Output:

Hallo, Taro!

Execution without arguments:

java Greeting

Output:

Hallo (Standard), 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("Geparste Optionen:");
        for (String key : options.keySet()) {
            System.out.println(key + " = " + options.get(key));
        }
    }
}

Execution:

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

Output:

Geparste Optionen:
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("Verwendung: java FileReaderTool <filePath>");
            return;
        }

        String filePath = args[0];
        try {
            String content = Files.readString(Paths.get(filePath));
            System.out.println("=== Inhalt von " + filePath + " ===");
            System.out.println(content);
        } catch (IOException e) {
            System.out.println("Fehler beim Lesen der Datei: " + e.getMessage());
        }
    }
}

Execution example:

java FileReaderTool data.txt

Sample output:

=== Inhalt von 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);
        }
    }
}

Ausführung:

java ModeSelector debug

Ausgabe:

Running in debug mode with detailed logging...

Wichtige Punkte:

• Nützlich zum Wechseln zwischen Entwicklung, Test- und Produktionsumgebungen.
• Weit verbreitet in Automatisierungsskripten und Batch-Jobs.

Automatisierung von Berechnungen mit mehreren Argumenten

In Batch-Verarbeitung und geplanten Skripten werden Argumente oft verwendet, um Parameter dynamisch zu übergeben.
Das folgende Beispiel zeigt ein einfaches Rechner-Tool, das mit zwei numerischen Werten arbeitet.

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

Ausführung:

java Calculator 8 2 mul

Ausgabe:

16.0

Dieser Ansatz ermöglicht es Ihnen, kleine, skriptfreundliche Tools zu erstellen, die sich leicht in Automatisierungs-Workflows integrieren lassen.

Spezifizierung von Konfigurationen mit Optionsargumenten

Für flexiblere Bedienung sind Optionsargumente im Stil von --key=value äußerst nützlich.

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

Ausführung:

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

Ausgabe:

Configuration file: prod.conf
Verbose logging: ON

Wichtige Punkte:

• Benannte Optionen reduzieren menschliche Fehler, da die Reihenfolge keine Rolle spielt.
• Häufig verwendet für Konfigurationspfade und Ausführungsmodi.

Praktisches Beispiel: Dateiverarbeitungstool mit 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("Datei erfolgreich kopiert: " + input + " → " + output);
            }
        } catch (IOException e) {
            System.out.println("Kopie fehlgeschlagen: " + e.getMessage());
        }
    }
}

Execution:

java FileCopyTool report.txt backup.txt --verbose

Output:

Datei erfolgreich kopiert: 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.

Mit diesen Techniken können Sie selbstbewusst Java-Programme entwickeln, testen und debuggen, die auf Kommandozeilenargumente angewiesen sind, und so ein konsistentes Verhalten in Entwicklungsumgebungen und Produktionsumgebungen gewährleisten.