Java - Command-Line Arguments

Hello, future Java programmers! Today, we're going to embark on an exciting journey into the world of command-line arguments in Java. As your friendly neighborhood computer science teacher, I'm here to guide you through this topic step by step. So, grab your favorite beverage, get comfortable, and let's dive in!

What Are Command-Line Arguments?

Imagine you're a chef (bear with me, we'll get to the coding soon!). You have a recipe, but sometimes you want to change the ingredients slightly. Instead of rewriting the entire recipe each time, wouldn't it be great if you could just tell the recipe what changes to make when you start cooking? That's essentially what command-line arguments do for our Java programs!

Command-line arguments are values that we can pass to our Java program when we run it from the command line. They allow us to provide input to our program without modifying the source code.

Passing & Accessing Command-Line Arguments

In Java, command-line arguments are passed to the main method as an array of strings. Let's look at a simple example:

public class Greeter {
public static void main(String[] args) {
if (args.length > 0) {
System.out.println("Hello, " + args[0] + "!");
} else {
System.out.println("Hello, World!");
}
}
}

In this example, args is an array that contains the command-line arguments. If we provide an argument when running the program, it will greet that name. Otherwise, it will default to "Hello, World!".

To run this program with a command-line argument, we would do:

java Greeter Alice

This would output: Hello, Alice!

Benefits of Command-Line Arguments

Flexibility: They allow us to change program behavior without modifying the code.
Automation: Useful for scripts and batch processing.
Testing: Makes it easy to test different inputs.
Configuration: Can be used to set program options.

Example of Single Command-Line Argument

Let's create a more practical example. Suppose we want to calculate the area of a circle, and we'll provide the radius as a command-line argument.

public class CircleArea {
public static void main(String[] args) {
if (args.length != 1) {
System.out.println("Please provide exactly one argument: the radius of the circle.");
return;
}

try {
double radius = Double.parseDouble(args[0]);
double area = Math.PI * radius * radius;
System.out.printf("The area of a circle with radius %.2f is %.2f\n", radius, area);
} catch (NumberFormatException e) {
System.out.println("The argument must be a valid number.");
}
}
}

To run this program, we would do:

java CircleArea 5

This would output: The area of a circle with radius 5.00 is 78.54

Let's break down what's happening here:

We check if exactly one argument is provided.
We use Double.parseDouble() to convert the string argument to a double.
We calculate the area using the formula πr².
We use printf to format our output nicely.
We catch NumberFormatException in case the input isn't a valid number.

Example of Multiple Command-Line Arguments

Now, let's step it up a notch and use multiple command-line arguments. We'll create a simple calculator that can add, subtract, multiply, or divide two numbers.

public class Calculator {
public static void main(String[] args) {
if (args.length != 3) {
System.out.println("Usage: java Calculator <number1> <operation> <number2>");
System.out.println("Operations: add, subtract, multiply, divide");
return;
}

try {
double num1 = Double.parseDouble(args[0]);
double num2 = Double.parseDouble(args[2]);
String operation = args[1].toLowerCase();

double result;
switch (operation) {
case "add":
result = num1 + num2;
break;
case "subtract":
result = num1 - num2;
break;
case "multiply":
result = num1 * num2;
break;
case "divide":
if (num2 == 0) {
System.out.println("Error: Division by zero!");
return;
}
result = num1 / num2;
break;
default:
System.out.println("Unknown operation: " + operation);
return;
}

System.out.printf("%.2f %s %.2f = %.2f\n", num1, operation, num2, result);
} catch (NumberFormatException e) {
System.out.println("Error: Invalid number format.");
}
}
}

To use this calculator, we would do something like:

java Calculator 10 add 5

This would output: 10.00 add 5.00 = 15.00

Let's break down this more complex example:

We check for exactly three arguments: two numbers and an operation.
We parse the first and third arguments as doubles.
We use a switch statement to perform the appropriate operation based on the second argument.
We handle potential errors, like division by zero or invalid operations.
Finally, we output the result in a nicely formatted string.

Conclusion

Command-line arguments are a powerful tool in a Java programmer's toolkit. They allow us to create flexible, reusable programs that can handle different inputs without needing to modify the source code. As you continue your Java journey, you'll find many more uses for command-line arguments, especially in more complex applications and scripts.

Remember, the key to mastering programming is practice. Try modifying these examples or creating your own programs that use command-line arguments. Maybe you could create a program that generates a customized greeting card based on command-line inputs, or a tool that converts between different units of measurement. The possibilities are endless!

Happy coding, and may your command-line arguments always be valid!

Java - Argumento Baris Perintah

Hai, para pemrogram Java masa depan! Hari ini, kita akan melangkah ke dalam dunia menarik dari argumen baris perintah dalam Java. Sebagai guru sains komputer yang ramah di lingkungan tetangga Anda, saya disini untuk mengarahkan Anda melalui topik ini langkah demi langkah. Jadi, ambil minuman favorit Anda, rasa nyaman, dan mari kita masuk ke dalam!

Apa Itu Argumen Baris Perintah?

Bayangkan Anda adalah seorang koki (teruskan, kita akan ke coding sebentar lagi!). Anda punya resep, tapi kadang-kadang Anda ingin mengubah bahan sedikit. Daripada menulis ulang seluruh resep setiap kali, tidakkah Anda merasa baik jika Anda bisa hanya memberitahu resep tentang perubahan yang akan Anda buat saat Anda mulai memasak? Itu sebenarnya apa yang argumen baris perintah lakukan untuk program Java kita!

Argumen baris perintah adalah nilai yang kita dapat kirim ke program Java kita saat kita menjalankan itu dari baris perintah. Mereka memungkinkan kita untuk menyediakan input ke program kita tanpa perlu mengubah kode sumber.

Menyampaikan & Mengakses Argumen Baris Perintah

Dalam Java, argumen baris perintah disampaikan ke metode main sebagai array string. Mari kita lihat contoh sederhana:

public class Greeter {
public static void main(String[] args) {
if (args.length > 0) {
System.out.println("Hello, " + args[0] + "!");
} else {
System.out.println("Hello, World!");
}
}
}

Dalam contoh ini, args adalah array yang berisi argumen baris perintah. Jika kita menyediakan argumen saat menjalankan program, itu akan menyapa nama itu. Jika tidak, itu akan default ke "Hello, World!".

Untuk menjalankan program ini dengan argumen baris perintah, kita akan melakukan:

java Greeter Alice

Ini akan menampilkan: Hello, Alice!

Manfaat Argumen Baris Perintah

Flexibilitas: Mereka memungkinkan kita untuk mengubah perilaku program tanpa mengubah kode.
Automatisasi: Berguna untuk skrip dan pengolahan batch.
Pengujian: Mempermudah pengujian input berbeda.
Konfigurasi: Dapat digunakan untuk mengatur pilihan program.

Contoh Argumen Baris Perintah Tunggal

Mari kita buat contoh yang lebih praktis. Suppos kita ingin menghitung luas lingkaran, dan kita akan menyediakan jari-jari sebagai argumen baris perintah.

public class CircleArea {
public static void main(String[] args) {
if (args.length != 1) {
System.out.println("Please provide exactly one argument: the radius of the circle.");
return;
}

try {
double radius = Double.parseDouble(args[0]);
double area = Math.PI * radius * radius;
System.out.printf("The area of a circle with radius %.2f is %.2f\n", radius, area);
} catch (NumberFormatException e) {
System.out.println("The argument must be a valid number.");
}
}
}

Untuk menjalankan program ini, kita akan melakukan:

java CircleArea 5

Ini akan menampilkan: The area of a circle with radius 5.00 is 78.54

Mari kitauraikan apa yang terjadi di sini:

Kita memeriksa jika tepat satu argumen yang disediakan.
Kita menggunakan Double.parseDouble() untuk mengkonversi argumen string ke double.
Kita menghitung luas menggunakan rumus πr².
Kita menggunakan printf untuk memformat output kita secara rapi.
Kita tangkap NumberFormatException jika input itu bukanlah sebuah nomor valid.

Contoh Argumen Baris Perintah Ganda

Sekarang, mari kita tingkatkan dan gunakan argumen baris perintah ganda. Kita akan membuat kalkulator sederhana yang dapat menambah, mengurangi, mengalikan, atau membagi dua nomor.

public class Calculator {
public static void main(String[] args) {
if (args.length != 3) {
System.out.println("Usage: java Calculator <number1> <operation> <number2>");
System.out.println("Operations: add, subtract, multiply, divide");
return;
}

try {
double num1 = Double.parseDouble(args[0]);
double num2 = Double.parseDouble(args[2]);
String operation = args[1].toLowerCase();

double result;
switch (operation) {
case "add":
result = num1 + num2;
break;
case "subtract":
result = num1 - num2;
break;
case "multiply":
result = num1 * num2;
break;
case "divide":
if (num2 == 0) {
System.out.println("Error: Division by zero!");
return;
}
result = num1 / num2;
break;
default:
System.out.println("Unknown operation: " + operation);
return;
}

System.out.printf("%.2f %s %.2f = %.2f\n", num1, operation, num2, result);
} catch (NumberFormatException e) {
System.out.println("Error: Invalid number format.");
}
}
}

Untuk menggunakan kalkulator ini, kita akan melakukan sesuatu seperti:

java Calculator 10 add 5

Ini akan menampilkan: 10.00 add 5.00 = 15.00

Mari kitauraikan contoh yang lebih kompleks ini:

Kita memeriksa untuk tepat tiga argumen: dua nomor dan operasi.
Kita mengkonversi argumen pertama dan ketiga menjadi double.
Kita menggunakan pernyataan switch untuk melakukan operasi yang sesuai berdasarkan argumen kedua.
Kita menangani kesalahan potensial, seperti pembagian nol atau operasi yang tak dikenal.
Akhirnya, kita menampilkan hasilnya dalam string yang diformat secara rapi.

Kesimpulan

Argumen baris perintah adalah alat yang kuat dalam peralatan pemrogram Java. Mereka memungkinkan kita untuk menciptakan program yang fleksibel dan dapat digunakan kembali yang dapat menangani input berbeda tanpa perlu mengubah kode sumber. Saat Anda terus melanjutkan perjalanan Java Anda, Anda akan menemukan banyak penggunaan lain untuk argumen baris perintah, khususnya dalam aplikasi dan skrip yang lebih kompleks.

Ingat, kunci untuk menjadi ahli pemrograman adalah latihan. Cobalah untuk mengubah contoh ini atau menciptakan program Anda sendiri yang menggunakan argumen baris perintah. Mungkin Anda dapat menciptakan program yang menghasilkan kartu ucapan yang disesuaikan berdasarkan input baris perintah, atau alat yang mengkonversi antara satuan ukuran berbeda. Kemungkinannya tak terbatas!

Selamat coding, dan semoga argumen baris perintah Anda selalu valid!

Credits: Image by storyset

Tutorial Sebelumnya:

Java - Interface Comparable di Java

Tutorial Seterusnya:

Java - Ekspresi Lambda