Ufafanuzi wa Vigezo vya Mstari wa Amri wa Java: Kutoka Misingi hadi Mifumo ya Ubunifu wa Kivitendo

1. Utangulizi

Kusudi la Sura Hii

Hoja za mstari wa amri za Java ni kipengele cha msingi kinachoruhusu programu kupokea maadili ya nje wakati wa utekelezaji na kubadilisha tabia yao ipasavyo. Hii makala inaeleza kila kitu kutoka maana ya String[] args hadi mifumo ya muundo inayotumiwa katika programu za ulimwengu halisi. Katika sura hii, kwanza tunafafanua nini hoja za mstari wa amri zinaweza kufanya na katika hali zipi ni muhimu.

Je, Hoja za Mstari wa Amri ni Nini?

Tumia programu ya Java kawaida huanza kutoka njia ya main yenye saini ifuatayo:

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

args ni jeraja ya mistari inayohifadhi maadili yaliyotolewa wakati programu inapoanzishwa. Kwa mfano:

javac App.java
java App Tokyo 2025 debug

Katika kesi hii, args ina ["Tokyo", "2025", "debug"].
Ikiwa hakuna hoja zinazotolewa, args.length ni 0.

Matumizi ya Kawaida

• Kubadilisha mazingira au malengo : hali ya uzalishaji dhidi ya hali ya majaribio, nambari za eneo, lugha, viwango vya kumbukumbu.
• Kutaja malengo ya uchakataji nje : majina ya faili za kuingiza, majukwaa, URL, orodha za Kitambulisho.
• Uchakataji wa kundi na otomatiki : kupitisha tarehe au anuwai kwa kazi zilizopangwa, kuingiza vigezo kutoka mifereji ya CI/CD.

Katika hali zote, tabia inaweza kubadilishwa bila kuandika upya, na kufanya hoja za mstari wa amri ziwe bora kwa matumizi na hati za ganda na mpangaji wa kazi kama cron.

Mazingatio ya Msingi ya Muundo

• Tenganisha hoja zinazohitajika na zisizohitajika : ikiwa hoja zinazohitajika zimepotea, shindwa wazi na pato la msaada au nambari za kutoka.
• Thibitisha mapema : badilisha maadili ya nambari au tarehe haraka iwezekanavyo na toa mwongozo wazi juu ya kuingiza batili.
• Unda maadili ya chaguo-msingi : hoja zisizohitajika ziwe na maadili salama ya chaguo-msingi ili programu iweze bado kuendesha.
• Uwezo wa kusomwa na matengenezo : epuka kutawanya upatikanaji wa moja kwa moja wa jeraja; tafuta hoja kwenye vitu vilivyopangwa (DTOs au madarasa ya usanidi).

Kuchagua Kati ya Hoja, Vigezo vya Mazingira, na Faili za Usanidi

• Hoja za mstari wa amri : bora kwa ubadilishaji wa muda mfupi au mipangilio maalum ya kazi (kipaumbele cha juu, usanidi uliobainishwa mahali).
• Vigezo vya mazingira : inafaa kwa siri au miisho inayotofautiana kwa kila mazingira ya kuweka.
• Faili za usanidi (sifa/JSON/YAML) : bora kwa kusimamia mipangilio mingi kimfumo na matumizi tena na udhibiti wa toleo.

Katika mazoezi, muundo wa tabaka tatu—faili za usanidi + vigezo vya mazingira + hoja za mstari wa amri—unaendesha vizuri, na hoja za mstari wa amri zinachukua kipaumbele cha juu zaidi.

Mfano Mdogo: Kuorodhesha Hoja Zote

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

Nini Hii Makala Inashughulikia Baadaye (Ramani ya Barabara)

• Shughuli za msingi kwenye String[] args (angalia urefu, upatikanaji wa kipengele)
• Ubadilishaji wa aina (int/double/boolean na udhibiti wa ubaguzi)
• Fomati za chaguo kama -v , --help , na --mode=prod
• Usanidi wa IDE na jinsi ya kupitisha hoja wakati wa majaribio
• Udhibiti wa makosa na mazingatio ya usalama (kuingiza batili, udhibiti wa ubaguzi)
• Mifano ya vitendo (uchakataji wa faili, kubadilisha hali, udhibiti wa kiwango cha kumbukumbu)

Kwanza, kumbuka kanuni hii ya msingi: hoja zote zinapitishwa kama mistari na lazima zibadilishwe na zithibitishwe kwa usalama kabla ya matumizi. Katika sura ijayo, tunachunguza sintaksisi ya msingi na mifumo ya kawaida na mifano halisi ya msimbo.

2. Je, Hoja za Mstari wa Amri ni Nini?

Uhusiano kati ya njia ya main na String[] args

Sehemu ya kuingia ya programu ya Java ni njia ya main, iliyobainishwa kama ifuatavyo:

public static void main(String[] args)

Hapa, args inasimulia “arguments” na ni array ya herufi inayohifadhi thamani zilizotumwa kutoka nje wakati programu inapoanza.
Unapoendesha programu, thamani zilizoainishwa baada ya java ClassName, zikitenganishwa kwa nafasi, huhifadhiwa mfululizo katika args.

Mfano: Kuendesha na Vigezo

javac Sample.java
java Sample apple orange banana

Katika kesi hii, maudhui ya args ni kama ifuatavyo:

Kwa maneno mengine, args inafanya kazi kama orodha ya herufi yenye urefu unaobadilika, ikikuruhusu kupitisha idadi yoyote ya thamani.
Ikiwa hakuna vigezo vilivyotajwa, args.length inakuwa 0 (haiwi kamwe null).

Mfano wa Utekelezaji na Matokeo

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

Matokeo:

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

Jambo muhimu hapa ni kwamba vigezo vyote vinapokelewa kama herufi.
Ikiwa unataka kuvitumia kama nambari au thamani za boolean, lazima uviweke wazi kwa ubadilishaji baadaye.

Ni Lini Unapaswa Kutumia Vigezo vya Mstari wa Amri?

Vigezo vya mstari wa amri hutumika mara nyingi katika hali zifuatazo:

• Kubadilisha hali za uendeshaji Mfano: java Server start vs java Server stop kufanya vitendo tofauti.
• Kuweka njia za faili au thamani za usanidi Mfano: java ReportGenerator /data/input.csv
• Kupitisha vigezo vya muda wakati wa utekelezaji wa script Mfano: tarehe, majina ya watumiaji, au kama mbadala wa uzito mdogo wa vigezo vya mazingira.

Matumizi haya yanaboresha ubadilifu na kuruhusu programu kudhibitiwa na ingizo la nje bila kuunda upya.

Tabia Wakati Hakuna Vigezo Vinavyotolewa

Njia ya main katika Java daima inajumuisha String[] args, hata wakati hakuna vigezo vilivyotumwa.
Ikiwa programu inatekelezwa bila vigezo, args.length == 0, hivyo kuongeza ukaguzi wa masharti kama ifuatayo inashauriwa:

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

Hii inaonyesha kipengele muhimu cha vigezo vya mstari wa amri: zinawaruhusu programu kupokea ingizo la nje linalobadilika wakati wa kuanza.

Muhtasari

• String[] args inahifadhi orodha ya vigezo vilivyotumwa wakati wa utekelezaji wa programu.
• Vigezo vyote vinashughulikiwa kama herufi .
• Hata wakati hakuna vigezo vilivyotolewa, args si null bali ni array tupu.
• Kutumia vigezo kunafanya programu kubadilika, kutumika tena, na rahisi kujiendesha kiotomatiki .

Katika sura inayofuata, tutajenga juu ya msingi huu na kuonyesha mifumo ya matumizi ya msingi na mifano ya msimbo halisi kwa kutoa na kutumia thamani kutoka args.

3. Matumizi ya Msingi na Mifano ya Msimbo

Sarufi ya Msingi ya Vigezo vya Mstari wa Amri

Ili kutumia vigezo vya mstari wa amri, kwanza unatoa thamani kutoka String[] args, ambayo inapitishwa kwa njia ya main.
Kwa kuwa args ni array, unaweza kufikia kila kipengele kwa kutumia faharasa yake.

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

Endesha programu kama ifuatavyo:

javac CommandExample.java
java CommandExample hello

Matokeo:

Number of arguments: 1
First argument: hello

Kama ilivyoonyeshwa hapo juu, args[0] huhifadhi thamani ya kwanza iliyotumwa. Ikiwa vigezo vingi vinatolewa, vinaweza kufikiwa kama args[1], args[2], n.k.

.### Kusindika Hoja Zote Mara Moja

Wakati idadi ya hoja inabadilika, kawaida kusindika kwa kutumia mzunguko.
Mfano ufuatao una chapisha hoja zote zilizopokelewa kwa mpangilio.

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

Utekelezaji:

java PrintArgs apple orange banana

Matokeo:

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

Kutumia mzunguko kunaruhusu programu yako kushughulikia idadi yoyote ya hoja.
Kama utaratibu bora, daima angalia urefu wa safu kabla ya kufikia vipengele.

Kuweka Maana Kulingana na Utaratibu wa Hoja

Unaweza kupewa maana maalum kwa hoja kulingana na utaratibu wao.
Kwa mfano, fikiria programu inayokubali jina la faili, hali, na ishara ya kuandika juu.

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

Mfano wa utekelezaji:

java FileProcessor data.txt simple false

Matokeo:

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

Kwa kupewa majukumu nafasi za hoja, unaweza kupata udhibiti wa programu unaobadilika.

Mfano: Kutendea Hoja Kama Nambari

Kwa kuwa hoja zote zinatolewa kama maandishi, ubadilishaji wa aina unahitajika wakati wa kuzitendea kama nambari.
Programu ifuatayo inapokea integer mbili na kuchapisha jumla yao.

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

Utekelezaji:

java SumArgs 7 13

Matokeo:

Sum: 20

Kama thamani isiyo ya nambari kama "abc" itatolewa, NumberFormatException itatokea.
Ili kufanya programu yako kuwa imara zaidi, unapaswa kuongeza usimamizi wa hitilafu.

Utekelezaji Salama Ukiwa na Usimamizi wa Hitilafu

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

Kwa usimamizi sahihi wa hitilafu, programu inaweza kurudisha ujumbe wazi badala ya kukoma ghafla wakati hoja batili zinapowekwa.

Muhtasari

final answer.* Vigezo vya mstari wa amri vinapapishwa kama maandishi katika safu args. * Daima angalia args.length kabla ya kufikia vipengele. * Tumia mizunguko kushughulikia idadi inayobadilika ya vigezo. * Badilisha thamani za nambari kwa kutumia mbinu kama Integer.parseInt(). * Tekeleza usimamizi wa hitilafu kwa tabia rafiki kwa mtumiaji.

Katika sura inayofuata, tutapitia makosa ya kawaida na tahadhari muhimu, na kuelezea jinsi ya kuandika msimbo salama zaidi na unaoweza kutumika tena.

4. Makosa ya Kawaida na Tahadhari

Ingawa vigezo vya mstari wa amri ni mbinu rahisi, kuna vizingiti kadhaa ambavyo wanaoanza hupata mara kwa mara.
Sura hii inatoa makosa ya kawaida na hatua za kiutendaji za kuzuia.

Makosa ya Kielekezo cha Safu (ArrayIndexOutOfBoundsException)

Makosa yanayojitokeza mara kwa mara ni kufikia kielekezo ambacho hakipo.
Kwa kuwa args ni safu, kutaja kielekezo kilicho nje ya safu husababisha hitilafu ifuatayo.

Mfano: Msimbo Usio Sahihi

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

Utekelezaji:

java ErrorExample

Matokeo:

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

Hatua ya Kuzuia

Daima angalia args.length kabla ya kufikia vipengele vya safu.

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

Jambo Muhimu:
args haijawahi kuwa null.
Hata wakati hakuna vigezo vilivyotolewa, bado ipo kama safu yenye urefu 0.

Vigezo Vyote Ni Maandishi

Vigezo vya mstari wa amri daima hupokelewa kama maandishi.
Kwa hiyo, ubadilishaji wa aina unahitajika kufanya mahesabu ya nambari.

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

Ikiwa maandishi yasiyo ya nambari kama "abc" yatapishwa, hitilafu ya NumberFormatException itatokea.

Hatua ya Kuzuia: Ongeza Usimamizi wa Hitilafu

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

Jambo Muhimu:
Kutumia vigezo moja kwa moja kama nambari ni hatari.
Daima chukua kuwa ingizo lililotolewa na mtumiaji linaweza kuwa batili.

Vigezo Vinavyobeba Nafasi

Katika mstari wa amri, nafasi zinachukuliwa kama vitenganishi vya vigezo.
Ili kupitisha maandishi yanayobeba nafasi, lazima uyaweke ndani ya alama za nukuu mbili.

Mfano:

java Message "Hello World"

Matokeo:

args[0] = Hello World

Ikiwa programu inatekelezwa bila alama za nukuu, "Hello" na "World" zitachukuliwa kama vigezo tofauti.

Kushughulikia Herufi za Multi-byte

Unapotuma herufi za multi-byte kama maandishi yasiyo ya ASCII, masuala ya usimbaji wa herufi yanaweza kutokea.
Katika mifumo ya Windows hasa, usimbaji wa console mara nyingi ni MS932 (Shift_JIS), ambao unaweza kuathiri programu za Java zinazotegemea UTF-8.

Hatua za Kuzuia:

• Weka kipengele cha amri kuwa UTF-8 kabla ya utekelezaji (chcp 65001).
• Unganisha usimbaji kuwa UTF-8 katika usanidi wa utekelezaji wa IDE (Eclipse / IntelliJ IDEA).
• Taja chaguo la kuanzisha Java -Dfile.encoding=UTF-8.

  java -Dfile.encoding=UTF-8 Sample Hello
  

Vigezo Vingi Sana au Virefu Sana

Kulingana na mfumo wa uendeshaji, kuna kikomo cha jumla ya urefu wa vigezo vya mstari wa amri.
Kwenye Windows, kikomo ni takriban herufi 8,000, wakati kwenye Linux ni takriban 128 KB.
Ikiwa unahitaji kushughulikia data nyingi, tumia ingizo la faili au ingizo la kawaida badala ya vigezo vya mstari wa amri.

Herufi Maalum na Utekelezaji wa Escape

Katika shells na command prompt, herufi fulani kama <, >, na & zina maana maalum.
Ili kuzipitia kama vigezo halisi, ziweke ndani ya alama za nukuu au uzifanye escape.

Mfano:

java SymbolTest "<tag>" "&value"

Hii inazuia ganda kutotafsiri vibaya herufi hizi kama opereta za kuelekeza au bomba.

Mpangilio Usio sahihi wa Hoja

Wakati mpangilio wa hoja unahamia, watumiaji wanaweza kutaja thamani kwa mpangilio usio sahihi kwa bahati mbaya.
Hii ni ya kawaida sana na jozi kama majina ya faili ya kuingiza na kutoa.

Hatua za Kuzuia:

• Tumia chaguzi zilizoitwa kama --input=input.txt (inayoshughulikiwa katika sura zinazofuata).
• Toa chaguo la help linaloeleza wazi matumizi.

Muhtasari

Katika sura inayofuata, tunaanzisha mifumo ya muundo wa vitendo kwa kutumia ubadilishaji wa aina, miundo ya chaguo, na thamani za default ili kujenga zana za command-line zenye nguvu zaidi.

5. Matumizi ya Vitendo: Ubadilishaji wa Aina, Hoja za Chaguo, na Thamani za Default

Katika sura hii, tunachunguza mbinu za kushughulikia hoja za command-line kwa njia inayobadilika zaidi na tayari kwa uzalishaji.
Kwa kutumia ubadilishaji wa aina, hoja za mtindo wa chaguo, na muundo wa thamani za default, unaweza kujenga programu ambazo ni salama zaidi na rahisi kwa watumiaji kuendesha.

Kubadilisha Hoja kuwa Aina za Nambari na Boolean

Hoja zote za command-line zinapitishwa kama thamani za String, lakini shughuli za hesabu na mantiki ya sharti zinahitaji aina sahihi za data.

Kubadilisha kuwa Nambari

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

Kubadilisha kuwa Boolean

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

Mfano: Programu ya Hesabu ya Nambari

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

Utekelezaji:

java Multiply 4.5 3

Matokeo:

Result: 13.5

Mambo muhimu:

• Daima funga ubadilishaji katika vizuizi vya try-catch ili kushughulikia kuingiza batili kwa usalama.
• Boolean.parseBoolean() inarudisha true tu wakati thamani inalingana na "true" , ikipuuza kesi.

Kuunda Hoja za Chaguo Zilizoitwa

Muundo unaotegemea mpangilio wa hoja unaweza kusababisha makosa ya kibinadamu.
Kutumia chaguo zilizoitwa kama --key=value au alama kama -v hufanya programu ziwe na busara zaidi.

Mfano: Kuchanganua Chaguo Zilizoitwa

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

Utekelezaji:

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

Matokeo:

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

Mambo muhimu:

• startsWith() inafanya iwe rahisi kugundua miundo ya --key=value.
• Hoja zinaweza kutajwa kwa mpangilio wowote.
• Inafaa vizuri kwa hati za ganda na kazi za kiotomatiki.

Kutoa Thamani za Default

Ni muhimu kufafanua thamani za default salama ikiwa hoja zimeachwa.
Hii inaruhusu programu kuendesha kwa kuingiza kidogo na kuzuia kumalizika kwa ghafla.

Mfano: Programu yenye Thamani za 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("Habari, " + name + "!");
        } else if (lang.equals("fr")) {
            System.out.println("Bonjour, " + name + "!");
        } else {
            System.out.println("Habari (chaguo-msingi), " + name + "!");
        }
    }
}

Execution:

java Greeting Taro en

Output:

Habari, Taro!

Execution without arguments:

java Greeting

Output:

Habari (chaguo-msingi), 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("Chaguo zilizochambuliwa:");
        for (String key : options.keySet()) {
            System.out.println(key + " = " + options.get(key));
        }
    }
}

Execution:

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

Output:

Chaguo zilizochambuliwa:
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("Matumizi: java FileReaderTool <filePath>");
            return;
        }

        String filePath = args[0];
        try {
            String content = Files.readString(Paths.get(filePath));
            System.out.println("=== Maudhui ya " + filePath + " ===");
            System.out.println(content);
        } catch (IOException e) {
            System.out.println("Imeshindwa kusoma faili: " + e.getMessage());
        }
    }
}

Execution example:

java FileReaderTool data.txt

Sample output:

=== Maudhui ya 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);
        }
    }
}

Utekelezaji:

java ModeSelector debug

Matokeo:

Running in debug mode with detailed logging...

Mambo Muhimu:

• Inafaa kwa kubadili kati ya mazingira ya maendeleo, majaribio, na uzalishaji.
• Inatumika sana katika skripiti za otomatiki na kazi za kundi.

Kufanya Hesabu Otomatiki na Hoja Nyingi

Katika uchakataji wa kundi na skripiti zilizopangwa, hoja hutumika mara nyingi kupitisha vigezo kwa nguvu.
Mfano ufuatao unaonyesha zana rahisi ya kukokotoa inayoendesha maadili mawili ya nambari.

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

Utekelezaji:

java Calculator 8 2 mul

Matokeo:

16.0

Njia hii inakuruhusu kuunda zana ndogo, zinazofaa skripiti ambazo zinaunganishwa kwa urahisi na mtiririko wa kazi za otomatiki.

Kutaja Usanidi na Hoja za Chaguo

Kwa uendeshaji unaobadilika zaidi, hoja za mtindo wa chaguo kama --key=value ni muhimu sana.

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

Utekelezaji:

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

Matokeo:

Configuration file: prod.conf
Verbose logging: ON

Mambo Muhimu:

• Chaguo zilizo na majina hupunguza makosa ya binadamu kwa sababu mpangilio haujali.
• Hutumika sana kwa njia za usanidi na hali za utekelezaji.

Mfano wa Vitendo: Zana ya Kuchakata Faili na Kuingiza Logi

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("Faili imekopiwa kwa mafanikio: " + input + " → " + output);
            }
        } catch (IOException e) {
            System.out.println("Nakili imeshindwa: " + e.getMessage());
        }
    }
}

Execution:

java FileCopyTool report.txt backup.txt --verbose

Output:

Faili imekopiwa kwa mafanikio: 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.

Kwa mbinu hizi, unaweza kwa ujasiri kuendeleza, kupima, na kurekebisha programu za Java zinazotegemea hoja za mstari wa amri, kuhakikisha tabia thabiti katika mazingira ya maendeleo na uzalishaji.