Giải Thích Đối Số Dòng Lệnh Java: Từ Cơ Bản Đến Các Mẫu Thiết Kế Thực Tiễn

1. Giới thiệu

Mục đích của Chương này

Các đối số dòng lệnh trong Java là một tính năng cơ bản cho phép chương trình nhận các giá trị bên ngoài tại thời gian chạy và thay đổi hành vi tương ứng. Bài viết này giải thích mọi thứ từ ý nghĩa của String[] args đến các mẫu thiết kế thực tiễn được sử dụng trong các ứng dụng thực tế. Trong chương này, chúng ta sẽ làm rõ những gì các đối số dòng lệnh có thể làm và trong những tình huống nào chúng hữu ích.

Đối số dòng lệnh là gì?

Một ứng dụng Java thường bắt đầu từ phương thức main với chữ ký sau:

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

args là một mảng các chuỗi lưu trữ các giá trị được cung cấp khi chương trình được khởi chạy. Ví dụ:

javac App.java
java App Tokyo 2025 debug

Trong trường hợp này, args chứa ["Tokyo", "2025", "debug"].
Nếu không có đối số nào được cung cấp, args.length sẽ bằng 0.

Các trường hợp sử dụng phổ biến

• Chuyển đổi môi trường hoặc mục tiêu : chế độ production vs testing, mã vùng, ngôn ngữ, mức độ log.
• Chỉ định mục tiêu xử lý từ bên ngoài : tên file đầu vào, thư mục, URL, danh sách ID.
• Xử lý batch và tự động hoá : truyền ngày tháng hoặc khoảng thời gian cho các job được lên lịch, tiêm các tham số từ pipeline CI/CD.

Trong mọi trường hợp, hành vi có thể được thay đổi mà không cần biên dịch lại, khiến các đối số dòng lệnh trở nên lý tưởng cho việc sử dụng với script shell và các bộ lập lịch công việc như cron.

Các yếu tố thiết kế quan trọng

• Tách biệt đối số bắt buộc và tùy chọn : nếu các đối số bắt buộc thiếu, hãy dừng chương trình một cách rõ ràng với thông báo trợ giúp hoặc mã thoát.
• Xác thực sớm : chuyển đổi các giá trị số hoặc ngày càng sớm càng tốt và cung cấp hướng dẫn rõ ràng khi đầu vào không hợp lệ.
• Thiết kế giá trị mặc định : các đối số tùy chọn nên có giá trị mặc định an toàn để chương trình vẫn có thể chạy.
• Độ dễ đọc và bảo trì : tránh việc truy cập mảng trực tiếp rải rác; hãy phân tích đối số thành các đối tượng có cấu trúc (DTO hoặc lớp cấu hình).

Lựa chọn giữa Đối số, Biến môi trường và Tệp cấu hình

• Đối số dòng lệnh : tốt nhất cho các ghi đè tạm thời hoặc cài đặt riêng cho từng job (ưu tiên cao nhất, cấu hình cục bộ).
• Biến môi trường : phù hợp cho các bí mật hoặc endpoint khác nhau tùy theo môi trường triển khai.
• Tệp cấu hình (properties/JSON/YAML) : lý tưởng cho việc quản lý nhiều cài đặt một cách có hệ thống, có thể tái sử dụng và kiểm soát phiên bản.

Trong thực tế, một thiết kế ba lớp — tệp cấu hình + biến môi trường + đối số dòng lệnh — hoạt động tốt, trong đó đối số dòng lệnh có độ ưu tiên cao nhất.

Ví dụ tối thiểu: Liệt kê tất cả các đối số

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

Những gì Bài viết này sẽ đề cập tiếp (lộ trình)

• Các thao tác cơ bản trên String[] args (kiểm tra độ dài, truy cập phần tử)
• Chuyển đổi kiểu (int/double/boolean và xử lý ngoại lệ)
• Định dạng tùy chọn như -v, --help và --mode=prod
• Cấu hình IDE và cách truyền đối số khi thử nghiệm
• Xử lý lỗi và các lưu ý bảo mật (đầu vào không hợp lệ, quản lý ngoại lệ)
• Các ví dụ thực tiễn (xử lý file, chuyển đổi chế độ, kiểm soát mức độ log)

Đầu tiên, hãy nhớ nguyên tắc cốt lõi này: tất cả các đối số đều được truyền dưới dạng chuỗi và phải được chuyển đổi và xác thực một cách an toàn trước khi sử dụng. Trong chương tiếp theo, chúng ta sẽ khám phá cú pháp cơ bản và các mẫu phổ biến với các ví dụ mã cụ thể.

2. Đối số dòng lệnh là gì?

.### Mối Quan Hệ Giữa Phương Thức main và String[] args

Điểm vào (entry point) của một ứng dụng Java là phương thức main, được định nghĩa như sau:

public static void main(String[] args)

Ở đây, args đại diện cho “arguments” và là một mảng chuỗi lưu trữ các giá trị được truyền vào từ bên ngoài khi chương trình khởi chạy.
Khi bạn chạy một chương trình, các giá trị được chỉ định sau java ClassName, cách nhau bằng dấu cách, sẽ được lưu tuần tự trong args.

Ví dụ: Chạy với Arguments

javac Sample.java
java Sample apple orange banana

Trong trường hợp này, nội dung của args như sau:

Nói cách khác, args hoạt động như một danh sách chuỗi có độ dài biến đổi, cho phép bạn truyền bất kỳ số lượng giá trị nào.
Nếu không có argument nào được chỉ định, args.length sẽ bằng 0 (nó không bao giờ là null).

Ví Dụ Thực Thi và Kết Quả

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

Kết quả:

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

Điểm quan trọng ở đây là tất cả các argument đều được nhận dưới dạng chuỗi.
Nếu bạn muốn sử dụng chúng như số hoặc giá trị boolean, bạn phải tự chuyển đổi chúng sau này.

Khi Nào Nên Sử Dụng Command-Line Arguments?

Command-line arguments thường được dùng trong các trường hợp sau:

• Chuyển đổi chế độ hoạt động Ví dụ: java Server start so với java Server stop để thực hiện các hành động khác nhau.
• Chỉ định đường dẫn tệp hoặc giá trị cấu hình Ví dụ: java ReportGenerator /data/input.csv
• Truyền các tham số tạm thời trong quá trình thực thi script Ví dụ: ngày tháng, tên người dùng, hoặc như các biến môi trường nhẹ nhàng.

Những trường hợp sử dụng này tăng tính linh hoạt và cho phép chương trình được điều khiển bởi đầu vào bên ngoài mà không cần biên dịch lại.

Hành Vi Khi Không Có Argument Được Cung Cấp

Phương thức main trong Java luôn bao gồm String[] args, ngay cả khi không có argument nào được truyền.
Nếu chương trình được thực thi mà không có argument, args.length == 0, vì vậy nên thêm một kiểm tra điều kiện như sau:

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

Điều này minh họa tính năng chính của command-line arguments: chúng cho phép chương trình nhận đầu vào linh hoạt, bên ngoài ngay khi khởi động.

Tóm Tắt

• String[] args chứa danh sách các argument được truyền vào khi thực thi chương trình.
• Tất cả các argument đều được xử lý dưới dạng chuỗi.
• Ngay cả khi không có argument nào được cung cấp, args cũng không phải là null mà là một mảng rỗng.
• Sử dụng argument làm cho chương trình linh hoạt, tái sử dụng và dễ tự động hoá.

Trong chương tiếp theo, chúng ta sẽ dựa trên nền tảng này và trình bày các mẫu sử dụng cơ bản và ví dụ mã cụ thể để trích xuất và sử dụng giá trị từ args.

3. Sử Dụng Cơ Bản và Ví Dụ Mã

Cú Pháp Cơ Bản của Command-Line Arguments

Để sử dụng command-line arguments, trước tiên bạn phải trích xuất các giá trị từ String[] args, đối tượng được truyền vào phương thức main.
Vì args là một mảng, bạn có thể truy cập từng phần tử bằng chỉ số của nó.

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

Chạy chương trình như sau:

javac CommandExample.java
java CommandExample hello

Kết quả:

Number of arguments: 1
First argument: hello

Như đã chỉ ra ở trên, args[0] lưu trữ giá trị đầu tiên được truyền vào.
Nếu có nhiều argument được cung cấp, chúng có thể được truy cập dưới dạng args[1], args[2], và tiếp tục như vậy.

Xử lý Tất cả Các Đối số Cùng Lúc

Khi số lượng đối số là biến đổi, việc xử lý chúng bằng cách sử dụng vòng lặp là phổ biến.
Ví dụ sau in tất cả các đối số nhận được theo thứ tự.

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

Thực thi:

java PrintArgs apple orange banana

Đầu ra:

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

Việc sử dụng vòng lặp cho phép chương trình của bạn xử lý bất kỳ số lượng đối số nào.
Là một thực hành tốt nhất, luôn kiểm tra độ dài mảng trước khi truy cập các phần tử.

Gán Ý nghĩa Dựa trên Thứ tự Đối số

Bạn có thể gán ý nghĩa cụ thể cho các đối số dựa trên thứ tự của chúng.
Ví dụ, hãy xem xét một chương trình chấp nhận tên tệp, chế độ và cờ ghi đè.

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

Ví dụ thực thi:

java FileProcessor data.txt simple false

Đầu ra:

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

Bằng cách gán vai trò cho các vị trí đối số, bạn có thể đạt được kiểm soát chương trình linh hoạt.

Ví dụ: Xử lý Các Đối số Như Các Số

Vì tất cả các đối số được truyền dưới dạng chuỗi, việc chuyển đổi kiểu là cần thiết khi xử lý chúng như các số.
Chương trình sau nhận hai số nguyên và in tổng của chúng.

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

Thực thi:

java SumArgs 7 13

Đầu ra:

Sum: 20

Nếu một giá trị không phải số như "abc" được truyền, một NumberFormatException sẽ xảy ra.
Để làm cho chương trình của bạn mạnh mẽ hơn, bạn nên thêm xử lý ngoại lệ.

Triển khai An toàn Với Xử lý Ngoại lệ

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

Với xử lý ngoại lệ đúng cách, chương trình có thể trả về các thông báo rõ ràng thay vì kết thúc đột ngột khi các đối số không hợp lệ được cung cấp.

Tóm tắt

• Các đối số dòng lệnh được truyền dưới dạng chuỗi trong mảng args.
• Luôn kiểm tra args.length trước khi truy cập các phần tử.
• Sử dụng vòng lặp để xử lý số lượng đối số biến đổi.
• Chuyển đổi giá trị số bằng các phương thức như Integer.parseInt().
• Thực hiện xử lý ngoại lệ để hành vi thân thiện với người dùng.

Trong chương tiếp theo, chúng ta sẽ xem xét các lỗi thường gặp và các biện pháp phòng ngừa quan trọng, đồng thời giải thích cách viết mã an toàn hơn và tái sử dụng được.

4. Các Lỗi Thường Gặp và Các Biện Pháp Phòng Ngừa

Mặc dù đối số dòng lệnh là một cơ chế đơn giản, nhưng vẫn có một số bẫy mà người mới thường gặp.
Chương này giới thiệu các lỗi điển hình và các biện pháp thực tiễn để ngăn ngừa chúng.

Lỗi Chỉ Mục Mảng (ArrayIndexOutOfBoundsException)

Lỗi phổ biến nhất là truy cập một chỉ mục không tồn tại.
Vì args là một mảng, việc chỉ định chỉ mục vượt quá phạm vi sẽ gây ra ngoại lệ sau.

Ví dụ: Mã Không Đúng

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

Thực thi:

java ErrorExample

Kết quả:

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

Biện pháp phòng ngừa

Luôn kiểm tra args.length trước khi truy cập các phần tử của mảng.

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

Điểm quan trọng:
args không bao giờ là null.
Ngay cả khi không có đối số nào được cung cấp, nó vẫn tồn tại dưới dạng một mảng có độ dài 0.

Tất Cả Các Đối Số Đều Là Chuỗi

Các đối số dòng lệnh luôn luôn được nhận dưới dạng chuỗi.
Do đó, cần thực hiện chuyển đổi kiểu để thực hiện các phép tính số học.

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

Nếu một chuỗi không phải số như "abc" được truyền vào, sẽ xảy ra NumberFormatException.

Biện pháp phòng ngừa: Thêm Xử Lý Ngoại Lệ

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

Điểm quan trọng:
Sử dụng trực tiếp các đối số như là số là rủi ro.
Luôn giả định rằng đầu vào do người dùng cung cấp có thể không hợp lệ.

Đối Số Chứa Dấu Cách

Trong dòng lệnh, dấu cách được coi là dấu phân tách các đối số.
Để truyền một chuỗi chứa dấu cách, bạn phải đặt nó trong dấu ngoặc kép.

Ví dụ:

java Message "Hello World"

Kết quả:

args[0] = Hello World

Nếu chương trình được thực thi mà không có dấu ngoặc kép, "Hello" và "World" sẽ được coi là các đối số riêng biệt.

Xử Lý Ký Tự Đa Byte

Khi truyền các ký tự đa byte như văn bản không phải ASCII, có thể xảy ra vấn đề mã hoá ký tự.
Đặc biệt trên hệ thống Windows, mã hoá console thường là MS932 (Shift_JIS), có thể xung đột với các chương trình Java dựa trên UTF‑8.

Các biện pháp:

• Đặt command prompt sang UTF‑8 trước khi chạy (chcp 65001).
• Đồng nhất mã hoá thành UTF‑8 trong cấu hình chạy của IDE (Eclipse / IntelliJ IDEA).
• Chỉ định tùy chọn khởi động Java -Dfile.encoding=UTF-8.

  java -Dfile.encoding=UTF-8 Sample Hello
  

Quá Nhiều Hoặc Quá Dài Các Đối Số

Tùy thuộc vào hệ điều hành, có giới hạn độ dài tổng cộng của các đối số dòng lệnh.
Trên Windows, giới hạn khoảng 8.000 ký tự, trong khi trên Linux khoảng 128 KB.
Nếu bạn cần xử lý một lượng dữ liệu lớn, hãy sử dụng đầu vào từ tệp hoặc stdin thay vì các đối số dòng lệnh.

Ký Tự Đặc Biệt và Việc Escape

Trong các shell và command prompt, một số ký tự như <, >, và & có ý nghĩa đặc biệt.
Để truyền chúng như là các đối số nguyên gốc, hãy đặt chúng trong dấu ngoặc kép hoặc escape chúng.

Ví dụ:

java SymbolTest "<tag>" "&value"

Điều này ngăn chặn shell hiểu sai các ký tự này là toán tử chuyển hướng hoặc pipe.

Thứ tự Đối số Sai

Khi thứ tự đối số quan trọng, người dùng có thể vô tình chỉ định giá trị theo thứ tự sai.
Điều này đặc biệt phổ biến với các cặp như tên tệp đầu vào và đầu ra.

Các biện pháp đối phó:

• Sử dụng tùy chọn có tên chẳng hạn như --input=input.txt (được đề cập trong các chương sau).
• Cung cấp tùy chọn help giải thích rõ ràng cách sử dụng.

Tóm tắt

Trong chương tiếp theo, chúng tôi giới thiệu các mẫu thiết kế thực tế sử dụng chuyển đổi kiểu, định dạng tùy chọn và giá trị mặc định để xây dựng các công cụ dòng lệnh mạnh mẽ hơn.

5. Sử dụng Thực tế: Chuyển đổi Kiểu, Đối số Tùy chọn, và Giá trị Mặc định

Trong chương này, chúng tôi khám phá các kỹ thuật xử lý đối số dòng lệnh một cách linh hoạt và sẵn sàng cho sản xuất hơn.
Bằng cách áp dụng chuyển đổi kiểu, đối số kiểu tùy chọn, và thiết kế giá trị mặc định, bạn có thể xây dựng các chương trình an toàn hơn và dễ sử dụng hơn cho người dùng.

Chuyển đổi Đối số sang Kiểu Số và Boolean

Tất cả các đối số dòng lệnh được truyền dưới dạng giá trị String, nhưng các phép toán số học và logic điều kiện yêu cầu các kiểu dữ liệu phù hợp.

Chuyển đổi sang Số

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

Chuyển đổi sang Boolean

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

Ví dụ: Chương trình Tính toán Số học

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

Thực thi:

java Multiply 4.5 3

Đầu ra:

Result: 13.5

Điểm chính:

• Luôn bao bọc các chuyển đổi trong khối try-catch để xử lý đầu vào không hợp lệ một cách an toàn.
• Boolean.parseBoolean() chỉ trả về true khi giá trị bằng "true" , bỏ qua chữ hoa chữ thường.

Thiết kế Đối số Tùy chọn Có Tên

Các thiết kế phụ thuộc vào thứ tự đối số dễ bị lỗi con người.
Sử dụng các tùy chọn có tên như --key=value hoặc cờ như -v làm cho chương trình trực quan hơn.

Ví dụ: Phân tích Cú pháp Tùy chọn Có Tên

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

Thực thi:

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

Đầu ra:

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

Điểm chính:

• startsWith() làm cho việc phát hiện định dạng --key=value trở nên dễ dàng.
• Các đối số có thể được chỉ định theo bất kỳ thứ tự nào.
• Phù hợp tốt cho các script shell và công việc tự động.

Cung cấp Giá trị Mặc định

Việc định nghĩa giá trị mặc định an toàn trong trường hợp đối số bị bỏ qua là rất quan trọng.
Điều này cho phép chương trình chạy với đầu vào tối thiểu và ngăn chặn việc kết thúc bất ngờ.

Ví dụ: Chương trình với Giá trị Mặc định

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("Xin chào, " + name + "!");
        } else if (lang.equals("fr")) {
            System.out.println("Bonjour, " + name + "!");
        } else {
            System.out.println("Xin chào (mặc định), " + name + "!");
        }
    }
}

Execution:

java Greeting Taro en

Output:

Xin chào, Taro!

Execution without arguments:

java Greeting

Output:

Xin chào (mặc định), 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("Tùy chọn đã phân tích:");
        for (String key : options.keySet()) {
            System.out.println(key + " = " + options.get(key));
        }
    }
}

Execution:

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

Output:

Tùy chọn đã phân tích:
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("Cách sử dụng: java FileReaderTool <filePath>");
            return;
        }

        String filePath = args[0];
        try {
            String content = Files.readString(Paths.get(filePath));
            System.out.println("=== Nội dung của " + filePath + " ===");
            System.out.println(content);
        } catch (IOException e) {
            System.out.println("Không thể đọc tệp: " + e.getMessage());
        }
    }
}

Execution example:

java FileReaderTool data.txt

Sample output:

=== Nội dung của data.txt ===
Dòng dữ liệu mẫu 1
Dòng dữ liệu mẫu 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);
        }
    }
}

Thực thi:

java ModeSelector debug

Kết quả:

Running in debug mode with detailed logging...

Các điểm chính:

• Hữu ích cho việc chuyển đổi giữa các môi trường phát triển, kiểm thử và sản xuất.
• Được sử dụng rộng rãi trong các script tự động và công việc batch.

Tự động hoá tính toán với nhiều đối số

Trong xử lý batch và các script được lên lịch, các đối số thường được sử dụng để truyền tham số một cách động.
Ví dụ sau đây cho thấy một công cụ tính toán đơn giản hoạt động trên hai giá trị số.

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

Thực thi:

java Calculator 8 2 mul

Kết quả:

16.0

Cách tiếp cận này cho phép bạn tạo các công cụ nhỏ, thân thiện với script có thể tích hợp dễ dàng vào quy trình tự động.

Xác định cấu hình với các đối số tùy chọn

Để hoạt động linh hoạt hơn, các đối số dạng tùy chọn như --key=value rất hữu ích.

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

Thực thi:

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

Kết quả:

Configuration file: prod.conf
Verbose logging: ON

Các điểm chính:

• Các tùy chọn có tên giảm lỗi của con người vì thứ tự không quan trọng.
• Thường được sử dụng cho các đường dẫn cấu hình và chế độ thực thi.

Ví dụ thực tế: Công cụ xử lý tệp với ghi log

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("Tệp đã được sao chép thành công: " + input + " → " + output);
            }
        } catch (IOException e) {
            System.out.println("Sao chép thất bại: " + e.getMessage());
        }
    }
}

Execution:

java FileCopyTool report.txt backup.txt --verbose

Output:

Tệp đã được sao chép thành công: 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.

Với những kỹ thuật này, bạn có thể tự tin phát triển, kiểm thử và gỡ lỗi các chương trình Java dựa trên đối số dòng lệnh, đảm bảo hành vi nhất quán trong cả môi trường phát triển và sản xuất.