Argumen Baris Perintah Java Dijelaskan: Dari Dasar hingga Pola Desain Praktis

1. Pendahuluan

Tujuan Bab Ini

Argumen baris perintah Java adalah fitur fundamental yang memungkinkan program menerima nilai eksternal pada saat runtime dan mengubah perilakunya sesuai. Artikel ini menjelaskan segala hal mulai dari arti String[] args hingga pola desain praktis yang digunakan dalam aplikasi dunia nyata. Pada bab ini, kami pertama-tama menjelaskan apa yang dapat dilakukan argumen baris perintah dan dalam situasi apa mereka berguna.

Apa Itu Argumen Baris Perintah?

Aplikasi Java biasanya dimulai dari metode main dengan tanda tangan berikut:

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

args adalah array string yang menyimpan nilai‑nilai yang diberikan saat program dijalankan. Contohnya:

javac App.java
java App Tokyo 2025 debug

Dalam kasus ini, args berisi ["Tokyo", "2025", "debug"].
Jika tidak ada argumen yang diberikan, args.length bernilai 0.

Kasus Penggunaan Umum

• Mengganti lingkungan atau target : mode produksi vs pengujian, kode wilayah, bahasa, tingkat log.
• Menentukan target pemrosesan secara eksternal : nama file masukan, direktori, URL, daftar ID.
• Pemrosesan batch dan otomatisasi : mengirim tanggal atau rentang ke pekerjaan terjadwal, menyuntikkan parameter dari pipeline CI/CD.

Dalam semua kasus, perilaku dapat diubah tanpa harus dikompilasi ulang, menjadikan argumen baris perintah ideal untuk digunakan dengan skrip shell dan penjadwal pekerjaan seperti cron.

Pertimbangan Desain Utama

• Pisahkan argumen wajib dan opsional : jika argumen wajib tidak ada, gagal dengan jelas melalui output bantuan atau kode keluar.
• Validasi lebih awal : konversi nilai numerik atau tanggal sesegera mungkin dan berikan panduan yang jelas untuk input yang tidak valid.
• Rancang nilai default : argumen opsional harus memiliki nilai default yang aman sehingga program tetap dapat dijalankan.
• Keterbacaan dan pemeliharaan : hindari penyebaran akses array langsung; parse argumen ke dalam objek terstruktur (DTO atau kelas konfigurasi).

Memilih Antara Argumen, Variabel Lingkungan, dan File Konfigurasi

• Argumen baris perintah : paling cocok untuk override sementara atau pengaturan khusus pekerjaan (prioritas tertinggi, konfigurasi lokal).
• Variabel lingkungan : cocok untuk rahasia atau endpoint yang berbeda per lingkungan penyebaran.
• File konfigurasi (properties/JSON/YAML) : ideal untuk mengelola banyak pengaturan secara sistematis dengan penggunaan kembali dan kontrol versi.

Dalam praktiknya, desain tiga lapis—file konfigurasi + variabel lingkungan + argumen baris perintah—bekerja dengan baik, dengan argumen baris perintah memiliki prioritas tertinggi.

Contoh Minimal: Menampilkan Semua Argumen

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

Apa yang Akan Dibahas Selanjutnya dalam Artikel Ini (Roadmap)

• Operasi dasar pada String[] args (pemeriksaan panjang, akses elemen)
• Konversi tipe (int/double/boolean dan penanganan pengecualian)
• Format opsi seperti -v, --help, dan --mode=prod
• Konfigurasi IDE dan cara mengirim argumen saat pengujian
• Penanganan error dan pertimbangan keamanan (input tidak valid, manajemen pengecualian)
• Contoh praktis (pemrosesan file, pergantian mode, kontrol tingkat log)

Pertama, ingat prinsip inti ini: semua argumen dikirim sebagai string dan harus dikonversi serta divalidasi secara aman sebelum digunakan. Pada bab berikutnya, kami akan mengeksplorasi sintaks dasar dan pola umum dengan contoh kode konkret.

2. Apa Itu Argumen Baris Perintah?

Hubungan Antara Metode main dan String[] args

Titik masuk (entry point) dari aplikasi Java adalah metode main, yang didefinisikan sebagai berikut:

public static void main(String[] args)

Di sini, args berarti “argument” dan merupakan array string yang menyimpan nilai-nilai yang diberikan dari luar saat program dimulai.
Ketika Anda menjalankan program, nilai-nilai yang ditentukan setelah java ClassName, dipisahkan oleh spasi, disimpan secara berurutan dalam args.

Contoh: Menjalankan dengan Argumen

javac Sample.java
java Sample apple orange banana

Dalam kasus ini, isi args adalah sebagai berikut:

Dengan kata lain, args berperilaku seperti daftar string dengan panjang variabel, memungkinkan Anda mengirimkan sejumlah nilai apa pun.
Jika tidak ada argumen yang ditentukan, args.length menjadi 0 (tidak pernah null).

Contoh Eksekusi dan Output

public class Sample {
    public static void main(String[] args) {
        System.out.println("Number of arguments: " + args.length);
        for (int i = 0; i < args.length; i++) {
            System.out.println("args[" + i + "] = " + args[i]);
        }
    }
}

java Sample dog cat

Output:

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

Poin penting di sini adalah semua argumen diterima sebagai string.
Jika Anda ingin menggunakannya sebagai angka atau nilai boolean, Anda harus secara eksplisit mengkonversinya nanti.

Kapan Anda Harus Menggunakan Argumen Baris Perintah?

Argumen baris perintah biasanya digunakan dalam skenario berikut:

• Mengganti mode operasi Contoh: java Server start vs java Server stop untuk melakukan aksi yang berbeda.
• Menentukan jalur file atau nilai konfigurasi Contoh: java ReportGenerator /data/input.csv
• Menyampaikan parameter sementara selama eksekusi skrip Contoh: tanggal, nama pengguna, atau sebagai pengganti ringan untuk variabel lingkungan.

Kasus penggunaan ini meningkatkan fleksibilitas dan memungkinkan program dikendalikan oleh input eksternal tanpa harus dikompilasi ulang.

Perilaku Saat Tidak Ada Argumen yang Diberikan

Metode main dalam Java selalu menyertakan String[] args, bahkan ketika tidak ada argumen yang diberikan.
Jika program dijalankan tanpa argumen, args.length == 0, sehingga menambahkan pemeriksaan kondisional seperti berikut disarankan:

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

Ini menunjukkan fitur utama dari argumen baris perintah: mereka memungkinkan program menerima input eksternal yang fleksibel saat startup.

Ringkasan

• String[] args menyimpan daftar argumen yang diberikan saat eksekusi program.
• Semua argumen diperlakukan sebagai string.
• Bahkan ketika tidak ada argumen yang diberikan, args bukan null melainkan array kosong.
• Menggunakan argumen membuat program fleksibel, dapat digunakan kembali, dan mudah diotomatisasi.

Pada bab berikutnya, kami akan melanjutkan dasar ini dan menunjukkan pola penggunaan dasar serta contoh kode konkret untuk mengekstrak dan menggunakan nilai-nilai dari args.

3. Penggunaan Dasar dan Contoh Kode

Sintaks Dasar Argumen Baris Perintah

Untuk menggunakan argumen baris perintah, pertama-tama Anda mengekstrak nilai-nilai dari String[] args, yang diteruskan ke metode main.
Karena args adalah sebuah array, Anda dapat mengakses setiap elemen dengan indeksnya.

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

Jalankan program sebagai berikut:

javac CommandExample.java
java CommandExample hello

Output:

Number of arguments: 1
First argument: hello

Seperti yang ditunjukkan di atas, args[0] menyimpan nilai pertama yang diberikan.
Jika beberapa argumen disediakan, mereka dapat diakses sebagai args[1], args[2], dan seterusnya.

Memproses Semua Argumen Sekaligus

Ketika jumlah argumen bersifat variabel, biasanya diproses menggunakan loop.
Contoh berikut mencetak semua argumen yang diterima secara berurutan.

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

Eksekusi:

java PrintArgs apple orange banana

Output:

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

Menggunakan loop memungkinkan program Anda menangani jumlah argumen berapa pun.
Sebagai praktik terbaik, selalu periksa panjang array sebelum mengakses elemen.

Menetapkan Makna Berdasarkan Urutan Argumen

Anda dapat memberikan makna khusus pada argumen berdasarkan urutannya.
Misalnya, pertimbangkan sebuah program yang menerima nama file, mode, dan flag timpa.

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

Contoh eksekusi:

java FileProcessor data.txt simple false

Output:

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

Dengan menetapkan peran pada posisi argumen, Anda dapat mencapai kontrol program yang fleksibel.

Contoh: Menganggap Argumen sebagai Angka

Karena semua argumen diteruskan sebagai string, konversi tipe diperlukan saat memperlakukan mereka sebagai angka.
Program berikut menerima dua bilangan bulat dan mencetak jumlahnya.

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

Eksekusi:

java SumArgs 7 13

Output:

Sum: 20

Jika nilai non-numerik seperti "abc" diteruskan, NumberFormatException akan terjadi.
Untuk membuat program Anda lebih kuat, Anda harus menambahkan penanganan pengecualian.

Implementasi Aman dengan Penanganan Pengecualian

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

Dengan penanganan pengecualian yang tepat, program dapat mengembalikan pesan yang jelas alih-alih menghentikan secara tiba-tiba ketika argumen tidak valid diberikan.

Ringkasan

• Argumen baris perintah diteruskan sebagai string dalam array args.
• Selalu periksa args.length sebelum mengakses elemen.
• Gunakan loop untuk menangani jumlah argumen yang variabel.
• Konversi nilai numerik menggunakan metode seperti Integer.parseInt().
• Terapkan penanganan pengecualian untuk perilaku yang ramah pengguna.

Pada bab berikutnya, kami meninjau kesalahan umum dan tindakan pencegahan penting, serta menjelaskan cara menulis kode yang lebih aman dan dapat digunakan kembali.

4. Kesalahan Umum dan Tindakan Pencegahan

Meskipun argumen baris perintah adalah mekanisme yang sederhana, ada beberapa jebakan yang sering ditemui pemula.
Bab ini memperkenalkan kesalahan tipikal dan langkah-langkah praktis untuk mencegahnya.

Kesalahan Indeks Array (ArrayIndexOutOfBoundsException)

Kesalahan yang paling sering terjadi adalah mengakses indeks yang tidak ada.
Karena args adalah sebuah array, menentukan indeks di luar jangkauan menghasilkan pengecualian berikut.

Contoh: Kode Salah

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

Eksekusi:

java ErrorExample

Output:

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

Tindakan Pencegahan

Selalu periksa args.length sebelum mengakses elemen array.

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

Poin penting:
args tidak pernah null.
Bahkan ketika tidak ada argumen yang diberikan, ia tetap ada sebagai array dengan panjang 0.

Semua Argumen Adalah String

Argumen baris perintah selalu diterima sebagai string.
Oleh karena itu, konversi tipe diperlukan untuk melakukan perhitungan numerik.

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

Jika string non-numerik seperti "abc" diberikan, akan terjadi NumberFormatException.

Tindakan Pencegahan: Tambahkan Penanganan Pengecualian

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

Poin penting:
Menggunakan argumen secara langsung sebagai angka berisiko.
Selalu anggap bahwa masukan yang diberikan pengguna mungkin tidak valid.

Argumen yang Mengandung Spasi

Di baris perintah, spasi diperlakukan sebagai pemisah argumen.
Untuk mengirimkan string yang mengandung spasi, Anda harus menutupnya dengan tanda kutip ganda.

Contoh:

java Message "Hello World"

Hasil:

args[0] = Hello World

Jika program dijalankan tanpa tanda kutip, "Hello" dan "World" diperlakukan sebagai argumen terpisah.

Menangani Karakter Multibyte

Saat mengirimkan karakter multibyte seperti teks non-ASCII, masalah pengkodean karakter dapat terjadi.
Pada sistem Windows khususnya, pengkodean konsol sering kali MS932 (Shift_JIS), yang dapat berbenturan dengan program Java berbasis UTF-8.

Tindakan Pencegahan:

• Atur prompt perintah ke UTF-8 sebelum eksekusi ( chcp 65001 ).
• Samakan pengkodean ke UTF-8 dalam konfigurasi jalankan IDE (Eclipse / IntelliJ IDEA).
• Tentukan opsi startup Java -Dfile.encoding=UTF-8 .

  java -Dfile.encoding=UTF-8 Sample Hello
  

Terlalu Banyak atau Terlalu Panjang Argumen

Tergantung pada sistem operasi, ada batas pada total panjang argumen baris perintah.
Pada Windows, batasnya kira-kira 8.000 karakter, sementara pada Linux sekitar 128 KB.
Jika Anda perlu menangani data dalam jumlah besar, gunakan input file atau input standar alih-alih argumen baris perintah.

Karakter Khusus dan Escape

Di shell dan prompt perintah, karakter tertentu seperti <, >, dan & memiliki makna khusus.
Untuk mengirimkannya sebagai argumen literal, tutup dengan tanda kutip atau escape mereka.

Contoh:

java SymbolTest "<tag>" "&value"

Ini mencegah shell menginterpretasikan karakter-karakter ini sebagai operator pengalihan atau pipa.

Urutan Argumen yang Salah

Ketika urutan argumen penting, pengguna dapat secara tidak sengaja menentukan nilai dalam urutan yang salah.
Hal ini terutama umum terjadi pada pasangan seperti nama file input dan output.

Langkah-langkah Pencegahan:

• Gunakan opsi bernama seperti --input=input.txt (dibahas di bab selanjutnya).
• Sediakan opsi help yang menjelaskan penggunaan dengan jelas.

Ringkasan

Di bab berikutnya, kami memperkenalkan pola desain praktis menggunakan konversi tipe, format opsi, dan nilai default untuk membangun alat baris perintah yang lebih kuat.

5. Penggunaan Praktis: Konversi Tipe, Argumen Opsi, dan Nilai Default

Pada bab ini, kami mengeksplorasi teknik untuk menangani argumen baris perintah dengan cara yang lebih fleksibel dan siap produksi.
Dengan menerapkan konversi tipe, argumen bergaya opsi, dan desain nilai default, Anda dapat membuat program yang lebih aman dan lebih mudah digunakan oleh pengguna.

Mengonversi Argumen ke Tipe Numerik dan Boolean

Semua argumen baris perintah diteruskan sebagai nilai String, tetapi operasi aritmetika dan logika kondisional memerlukan tipe data yang sesuai.

Mengonversi ke Angka

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

Mengonversi ke Boolean

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

Contoh: Program Perhitungan Numerik

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

Eksekusi:

java Multiply 4.5 3

Output:

Result: 13.5

Poin-poin penting:

• Selalu bungkus konversi dalam blok try-catch untuk menangani input yang tidak valid dengan aman.
• Boolean.parseBoolean() mengembalikan true hanya ketika nilai sama dengan "true", tanpa memperhatikan huruf besar/kecil.

Merancang Argumen Opsi Bernama

Desain yang bergantung pada urutan argumen rentan terhadap kesalahan manusia.
Menggunakan opsi bernama seperti --key=value atau flag seperti -v membuat program lebih intuitif.

Contoh: Mengurai Opsi Bernama

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

Eksekusi:

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

Output:

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

Poin-poin penting:

• startsWith() memudahkan deteksi format --key=value.
• Argumen dapat ditentukan dalam urutan apa pun.
• Sangat cocok untuk skrip shell dan pekerjaan otomatis.

Menyediakan Nilai Default

Penting untuk mendefinisikan nilai default yang aman bila argumen tidak diberikan.
Hal ini memungkinkan program berjalan dengan input minimal dan mencegah penghentian yang tidak terduga.

Contoh: Program dengan Nilai Default

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

Eksekusi:

java ModeSelector debug

Keluaran:

Running in debug mode with detailed logging...

Poin penting:

• Berguna untuk beralih antara lingkungan pengembangan, pengujian, dan produksi.
• Banyak digunakan dalam skrip otomatisasi dan pekerjaan batch.

Mengotomatisasi Perhitungan dengan Banyak Argumen

Dalam pemrosesan batch dan skrip terjadwal, argumen sering digunakan untuk mengirimkan parameter secara dinamis.
Contoh berikut menunjukkan alat kalkulator sederhana yang beroperasi pada dua nilai numerik.

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

Eksekusi:

java Calculator 8 2 mul

Keluaran:

16.0

Pendekatan ini memungkinkan Anda membuat alat kecil yang ramah skrip yang mudah terintegrasi dengan alur kerja otomatisasi.

Menentukan Konfigurasi dengan Argumen Opsi

Untuk operasi yang lebih fleksibel, argumen bergaya opsi seperti --key=value sangat berguna.

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

Eksekusi:

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

Keluaran:

Configuration file: prod.conf
Verbose logging: ON

Poin penting:

• Opsi bernama mengurangi kesalahan manusia karena urutan tidak penting.
• Umumnya digunakan untuk jalur konfigurasi dan mode eksekusi.

Contoh Praktis: Alat Pemrosesan File dengan Logging

import java.nio.file.*;
import java.io.*;

public class FileCopyTool {
    public static void main(String[] args) {
        if (args.length < 2) {
            System.out.println("Usage: java FileCopyTool <input> <output> [--verbose]");
            return;
        }

        String input = args[0];
        String output = args[1];
        boolean verbose = (args.length > 2 && args[2].equals("--verbose"));

        try {
            Files.copy(Paths.get(input), Paths.get(output), StandardCopyOption.REPLACE_EXISTING);
            if (verbose) {
                System.out.println("File 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.

Dengan teknik‑teknik ini, Anda dapat dengan percaya diri mengembangkan, menguji, dan men‑debug program Java yang bergantung pada argumen baris perintah, memastikan perilaku yang konsisten di seluruh lingkungan pengembangan dan produksi.