জাভা কমান্ড-লাইন আর্গুমেন্টস ব্যাখ্যা: মৌলিক থেকে ব্যবহারিক ডিজাইন প্যাটার্ন পর্যন্ত

১. পরিচিতি

এই অধ্যায়ের উদ্দেশ্য

Java কমান্ড-লাইন আর্গুমেন্ট হল একটি মৌলিক বৈশিষ্ট্য যা প্রোগ্রামকে রানটাইমে বাহ্যিক মান গ্রহণ করতে এবং তার আচরণ অনুযায়ী পরিবর্তন করতে সক্ষম করে। এই নিবন্ধটি String[] args এর অর্থ থেকে বাস্তব জগতে ব্যবহৃত ব্যবহারিক ডিজাইন প্যাটার্ন পর্যন্ত সবকিছু ব্যাখ্যা করে। এই অধ্যায়ে, আমরা প্রথমে স্পষ্ট করব কমান্ড-লাইন আর্গুমেন্ট কী করতে পারে এবং কোন পরিস্থিতিতে সেগুলি উপযোগী।

কমান্ড-লাইন আর্গুমেন্ট কী?

একটি Java অ্যাপ্লিকেশন সাধারণত নিম্নলিখিত স্বাক্ষরসহ একটি main মেথড থেকে শুরু হয়:

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

args হল স্ট্রিংয়ের একটি অ্যারে যা প্রোগ্রাম চালু করার সময় সরবরাহ করা মানগুলি সংরক্ষণ করে। উদাহরণস্বরূপ:

javac App.java
java App Tokyo 2025 debug

এই ক্ষেত্রে, args-এ রয়েছে ["Tokyo", "2025", "debug"]।
যদি কোনো আর্গুমেন্ট সরবরাহ না করা হয়, তবে args.length হবে 0।

সাধারণ ব্যবহার ক্ষেত্রসমূহ

• পরিবেশ বা লক্ষ্য পরিবর্তন : প্রোডাকশন বনাম টেস্টিং মোড, অঞ্চল কোড, ভাষা, লগ লেভেল।
• বাহ্যিকভাবে প্রক্রিয়াকরণ লক্ষ্য নির্ধারণ : ইনপুট ফাইলের নাম, ডিরেক্টরি, URL, আইডি তালিকা।
• ব্যাচ প্রক্রিয়াকরণ এবং অটোমেশন : নির্ধারিত কাজগুলিতে তারিখ বা রেঞ্জ পাস করা, CI/CD পাইপলাইন থেকে প্যারামিটার ইনজেক্ট করা।

সব ক্ষেত্রেই, আচরণ কম্পাইল না করেই পরিবর্তন করা যায়, যা শেল স্ক্রিপ্ট এবং ক্রন-এর মতো জব শিডিউলারগুলির সাথে ব্যবহার করার জন্য কমান্ড-লাইন আর্গুমেন্টকে আদর্শ করে তোলে।

মূল নকশা বিবেচ্য বিষয়সমূহ

• প্রয়োজনীয় এবং ঐচ্ছিক আর্গুমেন্ট আলাদা করুন : যদি বাধ্যতামূলক আর্গুমেন্ট অনুপস্থিত থাকে, তবে সহায়তা আউটপুট বা এক্সিট কোড দিয়ে স্পষ্টভাবে ব্যর্থ করুন।
• শুরুতেই যাচাই করুন : সংখ্যাসূচক বা তারিখের মান যত দ্রুত সম্ভব রূপান্তর করুন এবং অবৈধ ইনপুটের জন্য স্পষ্ট নির্দেশনা দিন।
• ডিফল্ট মান ডিজাইন করুন : ঐচ্ছিক আর্গুমেন্টের নিরাপদ ডিফল্ট মান থাকা উচিত যাতে প্রোগ্রাম এখনও চালু হতে পারে।
• পাঠযোগ্যতা এবং রক্ষণাবেক্ষণযোগ্যতা : সরাসরি অ্যারে অ্যাক্সেস ছড়িয়ে না দিয়ে; আর্গুমেন্টগুলোকে গঠিত অবজেক্টে (DTO বা কনফিগারেশন ক্লাস) পার্স করুন।

আর্গুমেন্ট, এনভায়রনমেন্ট ভেরিয়েবল এবং কনফিগ ফাইলের মধ্যে নির্বাচন

• কমান্ড-লাইন আর্গুমেন্ট : অস্থায়ী ওভাররাইড বা জব-নির্দিষ্ট সেটিংসের জন্য সর্বোত্তম (সর্বোচ্চ অগ্রাধিকার, লোকালাইজড কনফিগারেশন)।
• এনভায়রনমেন্ট ভেরিয়েবল : সিক্রেট বা এন্ডপয়েন্টের জন্য উপযুক্ত যা ডিপ্লয়মেন্ট পরিবেশ অনুযায়ী ভিন্ন হয়।
• কনফিগারেশন ফাইল (properties/JSON/YAML) : পুনর্ব্যবহার এবং ভার্সন কন্ট্রোল সহ বহু সেটিংসকে পদ্ধতিগতভাবে পরিচালনার জন্য আদর্শ।

প্র্যাকটিসে, একটি তিন-স্তরের নকশা—কনফিগারেশন ফাইল + এনভায়রনমেন্ট ভেরিয়েবল + কমান্ড-লাইন আর্গুমেন্ট—ভালো কাজ করে, যেখানে কমান্ড-লাইন আর্গুমেন্ট সর্বোচ্চ অগ্রাধিকার পায়।

ন্যূনতম উদাহরণ: সব আর্গুমেন্ট তালিকাভুক্ত করা

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

এই নিবন্ধে পরবর্তীতে যা কভার করা হবে (রোডম্যাপ)

• মৌলিক অপারেশন String[] args-এ (দৈর্ঘ্য চেক, উপাদান অ্যাক্সেস)
• টাইপ রূপান্তর (int/double/boolean এবং এক্সসেপশন হ্যান্ডলিং)
• অপশন ফরম্যাট যেমন -v, --help, এবং --mode=prod
• IDE কনফিগারেশন এবং টেস্টিংয়ের সময় কীভাবে আর্গুমেন্ট পাস করবেন
• এরর হ্যান্ডলিং এবং সিকিউরিটি বিবেচনা (অবৈধ ইনপুট, এক্সসেপশন ম্যানেজমেন্ট)
• প্র্যাকটিক্যাল উদাহরণ (ফাইল প্রক্রিয়াকরণ, মোড সুইচিং, লগ লেভেল কন্ট্রোল)

প্রথমে, এই মূল নীতি মনে রাখুন: সব আর্গুমেন্ট স্ট্রিং হিসেবে পাস হয় এবং ব্যবহার করার আগে সেগুলি নিরাপদে রূপান্তর এবং যাচাই করা প্রয়োজন। পরবর্তী অধ্যায়ে, আমরা মৌলিক সিনট্যাক্স এবং সাধারণ প্যাটার্নগুলোকে নির্দিষ্ট কোড উদাহরণসহ অনুসন্ধান করব।

২. কমান্ড-লাইন আর্গুমেন্ট কী?

মেইন মেথড এবং String[] args এর সম্পর্ক

একটি জাভা অ্যাপ্লিকেশনের এন্ট্রি পয়েন্ট হল main মেথড, যা নিম্নরূপ সংজ্ঞায়িত করা হয়:

public static void main(String[] args)

এখানে, args মানে “আর্গুমেন্টস” এবং এটি একটি স্ট্রিং অ্যারে যা প্রোগ্রাম শুরু হলে বাহ্যিকভাবে পাস করা মানগুলো সংরক্ষণ করে।
যখন আপনি একটি প্রোগ্রাম চালান, java ClassName এর পরে স্পেস দিয়ে আলাদা করা মানগুলো args এ ক্রমানুসারে সংরক্ষিত হয়।

উদাহরণ: আর্গুমেন্টস সহ চালানো

javac Sample.java
java Sample apple orange banana

এই ক্ষেত্রে, args এর বিষয়বস্তু নিম্নরূপ:

অন্য কথায়, args একটি ভেরিয়েবল-দৈর্ঘ্যের স্ট্রিং তালিকা এর মতো কাজ করে, যা আপনাকে যেকোনো সংখ্যক মান পাস করতে দেয়।
যদি কোনো আর্গুমেন্ট নির্দিষ্ট না করা হয়, তবে args.length হয় 0 (এটি কখনোই null হয় না)।

এক্সিকিউশন উদাহরণ এবং আউটপুট

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

আউটপুট:

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

এখানে গুরুত্বপূর্ণ বিষয় হল সব আর্গুমেন্ট স্ট্রিং হিসেবে গ্রহণ করা হয়।
যদি আপনি সেগুলোকে সংখ্যা বা বুলিয়ান মান হিসেবে ব্যবহার করতে চান, তবে পরে স্পষ্টভাবে রূপান্তর করতে হবে।

কখন আপনি কমান্ড-লাইন আর্গুমেন্ট ব্যবহার করবেন?

কমান্ড-লাইন আর্গুমেন্ট সাধারণত নিম্নলিখিত পরিস্থিতিতে ব্যবহার করা হয়:

• অপারেশন মোড পরিবর্তন করা উদাহরণ: java Server start বনাম java Server stop ভিন্ন কাজ সম্পাদনের জন্য।
• ফাইল পাথ বা কনফিগারেশন মান নির্ধারণ করা উদাহরণ: java ReportGenerator /data/input.csv
• স্ক্রিপ্ট এক্সিকিউশনের সময় অস্থায়ী প্যারামিটার পাস করা উদাহরণ: তারিখ, ব্যবহারকারীর নাম, অথবা পরিবেশ ভেরিয়েবলের হালকা বিকল্প হিসেবে।

এই ব্যবহারিক ক্ষেত্রগুলো নমনীয়তা বাড়ায় এবং প্রোগ্রামগুলোকে পুনরায় কম্পাইল না করে বাহ্যিক ইনপুট দ্বারা নিয়ন্ত্রিত হতে দেয়।

কোনো আর্গুমেন্ট না দেওয়া হলে আচরণ

জাভায় main মেথড সর্বদা String[] args অন্তর্ভুক্ত করে, যদিও কোনো আর্গুমেন্ট পাস না করা হয়।
যদি প্রোগ্রামটি কোনো আর্গুমেন্ট ছাড়া চালানো হয়, args.length == 0 হয়, তাই নিম্নলিখিত শর্তযুক্ত চেক যোগ করা সুপারিশ করা হয়:

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

এটি কমান্ড-লাইন আর্গুমেন্টের মূল বৈশিষ্ট্য প্রদর্শন করে: এগুলো প্রোগ্রামকে স্টার্টআপে নমনীয়, বাহ্যিক ইনপুট গ্রহণ করতে দেয়।

সারাংশ

• String[] args প্রোগ্রাম এক্সিকিউশনের সময় পাস করা আর্গুমেন্টের তালিকা ধারণ করে।
• সব আর্গুমেন্ট স্ট্রিং হিসেবে হ্যান্ডল করা হয়।
• যদিও কোনো আর্গুমেন্ট প্রদান করা না হয়, args null নয় বরং একটি খালি অ্যারে।
• আর্গুমেন্ট ব্যবহার করলে প্রোগ্রামগুলো নমনীয়, পুনর্ব্যবহারযোগ্য এবং স্বয়ংক্রিয় করা সহজ হয়।

পরবর্তী অধ্যায়ে, আমরা এই ভিত্তির উপর ভিত্তি করে মৌলিক ব্যবহার প্যাটার্ন এবং নির্দিষ্ট কোড উদাহরণ দেখাবো, যা args থেকে মান বের করা এবং ব্যবহার করার জন্য।

৩. মৌলিক ব্যবহার এবং কোড উদাহরণ

কমান্ড-লাইন আর্গুমেন্টের মৌলিক সিনট্যাক্স

কমান্ড-লাইন আর্গুমেন্ট ব্যবহার করতে, প্রথমে আপনাকে String[] args থেকে মান বের করতে হবে, যা main মেথডে পাস করা হয়।
args একটি অ্যারে হওয়ায়, আপনি প্রতিটি উপাদানকে তার ইনডেক্স দিয়ে অ্যাক্সেস করতে পারেন।

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

প্রোগ্রামটি নিম্নরূপ চালান:

javac CommandExample.java
java CommandExample hello

আউটপুট:

Number of arguments: 1
First argument: hello

উপরের মতো, args[0] প্রথম পাস করা মান সংরক্ষণ করে।
যদি একাধিক আর্গুমেন্ট প্রদান করা হয়, তবে সেগুলোকে args[1], args[2] ইত্যাদি হিসেবে অ্যাক্সেস করা যায়।

সকল আর্গুমেন্ট একসঙ্গে প্রক্রিয়াকরণ

যখন আর্গুমেন্টের সংখ্যা পরিবর্তনশীল হয়, তখন লুপ ব্যবহার করে তাদের প্রক্রিয়া করা সাধারণ।
নিম্নলিখিত উদাহরণটি প্রাপ্ত সকল আর্গুমেন্টকে ক্রমানুসারে প্রিন্ট করে।

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

চালনা:

java PrintArgs apple orange banana

আউটপুট:

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

লুপ ব্যবহার করে আপনার প্রোগ্রাম যেকোনো সংখ্যক আর্গুমেন্ট হ্যান্ডেল করতে পারে।
সেরা অনুশীলন হিসেবে, এলিমেন্ট অ্যাক্সেস করার আগে সর্বদা অ্যারে-এর দৈর্ঘ্য চেক করুন।

আর্গুমেন্টের ক্রমের উপর ভিত্তি করে অর্থ নির্ধারণ

আপনি আর্গুমেন্টগুলোর ক্রমের উপর ভিত্তি করে তাদের নির্দিষ্ট অর্থ নির্ধারণ করতে পারেন।
উদাহরণস্বরূপ, একটি প্রোগ্রাম বিবেচনা করুন যা একটি ফাইলের নাম, একটি মোড এবং একটি ওভাররাইট ফ্ল্যাগ গ্রহণ করে।

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

চালনার উদাহরণ:

java FileProcessor data.txt simple false

আউটপুট:

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

আর্গুমেন্টের অবস্থানগুলোতে ভূমিকা নির্ধারণ করে, আপনি নমনীয় প্রোগ্রাম নিয়ন্ত্রণ অর্জন করতে পারেন।

উদাহরণ: আর্গুমেন্টগুলোকে সংখ্যা হিসেবে বিবেচনা

যেহেতু সকল আর্গুমেন্ট স্ট্রিং হিসেবে পাস করা হয়, তাই তাদের সংখ্যা হিসেবে বিবেচনা করার সময় টাইপ রূপান্তর প্রয়োজন।
নিম্নলিখিত প্রোগ্রামটি দুটি পূর্ণসংখ্যা গ্রহণ করে এবং তাদের যোগফল প্রিন্ট করে।

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

চালনা:

java SumArgs 7 13

আউটপুট:

Sum: 20

যদি "abc"-এর মতো অ-সংখ্যাত্মক মান পাস করা হয়, তাহলে NumberFormatException ঘটবে।
আপনার প্রোগ্রামকে আরও শক্তিশালী করার জন্য, আপনার এক্সেপশন হ্যান্ডলিং যোগ করা উচিত।

এক্সেপশন হ্যান্ডলিং সহ নিরাপদ বাস্তবায়ন

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

উপযুক্ত এক্সেপশন হ্যান্ডলিং সহ, প্রোগ্রামটি অবৈধ আর্গুমেন্ট প্রদান করলে হঠাৎ শেষ হওয়ার পরিবর্তে স্পষ্ট বার্তা প্রদান করতে পারে।

সারাংশ

• কমান্ড-লাইন আর্গুমেন্টগুলি args অ্যারেতে স্ট্রিং হিসেবে পাস করা হয়।
• উপাদানগুলোতে অ্যাক্সেস করার আগে সর্বদা args.length পরীক্ষা করুন।
• ভেরিয়েবল সংখ্যক আর্গুমেন্ট হ্যান্ডেল করতে লুপ ব্যবহার করুন।
• Integer.parseInt() এর মতো মেথড ব্যবহার করে সংখ্যামূলক মান রূপান্তর করুন।
• ব্যবহারকারী-বান্ধব আচরণের জন্য এক্সসেপশন হ্যান্ডলিং বাস্তবায়ন করুন।

পরবর্তী অধ্যায়ে, আমরা সাধারণ ভুল এবং গুরুত্বপূর্ণ সতর্কতা পর্যালোচনা করব, এবং কীভাবে আরও নিরাপদ ও পুনঃব্যবহারযোগ্য কোড লিখতে হয় তা ব্যাখ্যা করব।

৪. সাধারণ ভুল এবং সতর্কতা

যদিও কমান্ড-লাইন আর্গুমেন্টগুলি একটি সহজ পদ্ধতি, তবুও নবীনরা প্রায়শই কিছু সমস্যার সম্মুখীন হয়।
এই অধ্যায়ে সাধারণ ভুল এবং সেগুলি প্রতিরোধের জন্য ব্যবহারিক প্রতিকারগুলি উপস্থাপন করা হয়েছে।

অ্যারে ইনডেক্স ত্রুটি (ArrayIndexOutOfBoundsException)

সবচেয়ে সাধারণ ভুল হল এমন একটি ইনডেক্সে অ্যাক্সেস করা যা অস্তিত্ব নেই।
কারণ args একটি অ্যারে, তাই সীমার বাইরে ইনডেক্স নির্দিষ্ট করলে নিম্নলিখিত এক্সসেপশন ঘটে।

উদাহরণ: ভুল কোড

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

চালানো:

java ErrorExample

আউটপুট:

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

প্রতিকার

অ্যারে উপাদানে অ্যাক্সেস করার আগে সর্বদা args.length পরীক্ষা করুন।

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

মূল বিষয়:
args কখনই null নয়।
যদিও কোনো আর্গুমেন্ট প্রদান করা না হয়, তবুও এটি দৈর্ঘ্য 0 সহ একটি অ্যারে হিসেবে থাকে।

সব আর্গুমেন্টই স্ট্রিং

কমান্ড-লাইন আর্গুমেন্টগুলি সর্বদা স্ট্রিং হিসেবে গ্রহণ করা হয়।
অতএব, সংখ্যামূলক গণনা করার জন্য টাইপ রূপান্তর প্রয়োজন।

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

যদি "abc" এর মতো অ-সংখ্যাত্মক স্ট্রিং পাস করা হয়, তবে NumberFormatException ঘটবে।

প্রতিকার: এক্সসেপশন হ্যান্ডলিং যোগ করুন

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

মূল বিষয়:
আর্গুমেন্টগুলোকে সরাসরি সংখ্যা হিসেবে ব্যবহার করা ঝুঁকিপূর্ণ।
সর্বদা ধরে নিন যে ব্যবহারকারী প্রদত্ত ইনপুট অবৈধ হতে পারে।

স্পেসযুক্ত আর্গুমেন্ট

কমান্ড লাইনে, স্পেসগুলোকে আর্গুমেন্ট বিভাজক হিসেবে বিবেচনা করা হয়।
স্পেসযুক্ত স্ট্রিং পাস করতে হলে আপনাকে ডাবল কোটেশন মার্কে ঘেরে রাখতে হবে।

উদাহরণ:

java Message "Hello World"

ফলাফল:

args[0] = Hello World

যদি প্রোগ্রামটি কোটেশন মার্ক ছাড়া চালানো হয়, তবে "Hello" এবং "World" আলাদা আর্গুমেন্ট হিসেবে বিবেচিত হবে।

মাল্টিবাইট ক্যারেক্টার হ্যান্ডলিং

নন-ASCII টেক্সটের মতো মাল্টিবাইট ক্যারেক্টার পাস করার সময়, ক্যারেক্টার এনকোডিং সমস্যাগুলি ঘটতে পারে।
বিশেষ করে উইন্ডোজ সিস্টেমে, কনসোলের এনকোডিং প্রায়শই MS932 (Shift_JIS) হয়, যা UTF-8-ভিত্তিক জাভা প্রোগ্রামের সঙ্গে সংঘর্ষ করতে পারে।

প্রতিকারসমূহ:

• এক্সিকিউশনের আগে কমান্ড প্রম্পটকে UTF-8-এ সেট করুন ( chcp 65001 )।
• IDE রান কনফিগারেশনে (Eclipse / IntelliJ IDEA) এনকোডিংকে UTF-8-এ একীভূত করুন।
• জাভা স্টার্টআপ অপশন -Dfile.encoding=UTF-8 নির্দিষ্ট করুন।

  java -Dfile.encoding=UTF-8 Sample Hello
  

অতিরিক্ত বা অতিরিক্ত দীর্ঘ আর্গুমেন্ট

অপারেটিং সিস্টেমের উপর নির্ভর করে, কমান্ড-লাইন আর্গুমেন্টের মোট দৈর্ঘ্যের সীমা থাকে।
উইন্ডোজে এই সীমা প্রায় ৮,০০০ ক্যারেক্টার, আর লিনাক্সে প্রায় ১২৮ কিলোবাইট।
যদি বড় পরিমাণের ডেটা হ্যান্ডেল করতে হয়, তবে কমান্ড-লাইন আর্গুমেন্টের পরিবর্তে ফাইল ইনপুট বা স্ট্যান্ডার্ড ইনপুট ব্যবহার করুন।

বিশেষ ক্যারেক্টার এবং এস্কেপিং

শেল এবং কমান্ড প্রম্পটে, <, >, এবং & এর মতো কিছু ক্যারেক্টারের বিশেষ অর্থ থাকে।
এগুলোকে লিটারাল আর্গুমেন্ট হিসেবে পাস করতে হলে কোটেশন মার্কে ঘেরে রাখুন অথবা এস্কেপ করুন।

উদাহরণ:

java SymbolTest "<tag>" "&value"

এটি শেলকে এই অক্ষরগুলোকে রিডাইরেকশন বা পাইপ অপারেটর হিসেবে ভুলভাবে ব্যাখ্যা করতে বাধা দেয়।

ভুল আর্গুমেন্ট ক্রম

যখন আর্গুমেন্টের ক্রম গুরুত্বপূর্ণ, তখন ব্যবহারকারীরা দুর্ঘটনাবশত ইনপুট এবং আউটপুট ফাইলের নামের মতো জোড়ায় ভুল ক্রমে মান নির্দিষ্ট করতে পারেন।
এটি বিশেষ করে ইনপুট এবং আউটপুট ফাইলের নামের মতো জোড়ায় সাধারণ।

প্রতিরোধমূলক ব্যবস্থা:

• নামকরণ করা অপশন ব্যবহার করুন যেমন --input=input.txt (পরবর্তী অধ্যায়ে আলোচিত)।
• একটি help অপশন প্রদান করুন যা ব্যবহারের স্পষ্ট ব্যাখ্যা দেয়।

সারাংশ

পরবর্তী অধ্যায়ে, আমরা টাইপ রূপান্তর, অপশন ফরম্যাট এবং ডিফল্ট মান ব্যবহার করে ব্যবহারিক ডিজাইন প্যাটার্ন পরিচয় করব যা আরও শক্তিশালী কমান্ড-লাইন টুল তৈরি করতে সাহায্য করে।

৫. ব্যবহারিক ব্যবহার: টাইপ রূপান্তর, অপশন আর্গুমেন্ট এবং ডিফল্ট মান

এই অধ্যায়ে, আমরা কমান্ড-লাইন আর্গুমেন্টগুলোকে আরও নমনীয় এবং প্রোডাকশন-রেডি উপায়ে হ্যান্ডেল করার কৌশল অন্বেষণ করব।
টাইপ রূপান্তর, অপশন-স্টাইল আর্গুমেন্ট এবং ডিফল্ট মান ডিজাইন প্রয়োগ করে, আপনি এমন প্রোগ্রাম তৈরি করতে পারেন যা নিরাপদ এবং ব্যবহারকারীদের জন্য সহজে পরিচালনা করা যায়।

আর্গুমেন্টগুলোকে সংখ্যামূলক এবং বুলিয়ান টাইপে রূপান্তর করা

সকল কমান্ড-লাইন আর্গুমেন্ট String মান হিসেবে পাস করা হয়, কিন্তু অঙ্কগণিত অপারেশন এবং শর্তসাপেক্ষ লজিকের জন্য উপযুক্ত ডেটা টাইপ প্রয়োজন।

সংখ্যায় রূপান্তর করা

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

বুলিয়ানে রূপান্তর করা

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

উদাহরণ: সংখ্যামূলক গণনা প্রোগ্রাম

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

এক্সিকিউশন:

java Multiply 4.5 3

আউটপুট:

Result: 13.5

মূল পয়েন্ট:

• অবৈধ ইনপুট নিরাপদে হ্যান্ডেল করার জন্য সর্বদা রূপান্তরগুলোকে try-catch ব্লকে আবৃত করুন।
• Boolean.parseBoolean() শুধুমাত্র মান "true" এর সমান হলে true ফেরত দেয়, কেস অগ্রাহ্য করে।

নামকরণ করা অপশন আর্গুমেন্ট ডিজাইন করা

আর্গুমেন্ট ক্রমের উপর নির্ভরশীল ডিজাইনগুলো মানুষীয় ত্রুটির জন্য প্রবণ।
--key=value এর মতো নামকরণ করা অপশন বা -v এর মতো ফ্ল্যাগ ব্যবহার করে প্রোগ্রামগুলোকে আরও স্বজ্ঞাত করে।

উদাহরণ: নামকরণ করা অপশন পার্সিং

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

এক্সিকিউশন:

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

আউটপুট:

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

মূল পয়েন্ট:

• startsWith() --key=value ফরম্যাট সনাক্ত করতে সহজ করে।
• আর্গুমেন্টগুলো যেকোনো ক্রমে নির্দিষ্ট করা যায়।
• শেল স্ক্রিপ্ট এবং অটোমেটেড জবের জন্য উপযুক্ত।

ডিফল্ট মান প্রদান করা

আর্গুমেন্টগুলো বাদ দেওয়া হলে নিরাপদ ডিফল্ট মান সংজ্ঞায়িত করা গুরুত্বপূর্ণ।
এটি প্রোগ্রামকে ন্যূনতম ইনপুট দিয়ে চালানোর অনুমতি দেয় এবং অপ্রত্যাশিত টার্মিনেশন প্রতিরোধ করে।

উদাহরণ: ডিফল্ট মান সহ প্রোগ্রাম

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

নির্বাহ:

java ModeSelector debug

আউটপুট:

Running in debug mode with detailed logging...

মূল পয়েন্ট:

• ডেভেলপমেন্ট, টেস্টিং এবং প্রোডাকশন পরিবেশের মধ্যে সুইচ করার জন্য উপযোগী।
• অটোমেশন স্ক্রিপ্ট এবং ব্যাচ কাজগুলিতে ব্যাপকভাবে ব্যবহৃত হয়।

একাধিক আর্গুমেন্ট সহ গণনা স্বয়ংক্রিয়করণ

ব্যাচ প্রসেসিং এবং নির্ধারিত স্ক্রিপ্টে, আর্গুমেন্টগুলি প্রায়ই প্যারামিটারগুলি গতিশীলভাবে পাস করতে ব্যবহৃত হয়।
নিম্নলিখিত উদাহরণটি একটি সহজ ক্যালকুলেটর টুল দেখায় যা দুটি সংখ্যামূলক মানের উপর কাজ করে।

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

নির্বাহ:

java Calculator 8 2 mul

আউটপুট:

16.0

এই পদ্ধতি আপনাকে ছোট, স্ক্রিপ্ট-বন্ধু টুল তৈরি করতে দেয় যা অটোমেশন ওয়ার্কফ্লোতে সহজে সংযুক্ত হয়।

অপশন আর্গুমেন্ট দিয়ে কনফিগারেশন নির্ধারণ

আরও নমনীয় অপারেশনের জন্য, --key=value এর মতো অপশন-স্টাইল আর্গুমেন্টগুলি অত্যন্ত উপযোগী।

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

নির্বাহ:

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

আউটপুট:

Configuration file: prod.conf
Verbose logging: ON

মূল পয়েন্ট:

• নামযুক্ত অপশনগুলি মানবিক ত্রুটি কমায় কারণ ক্রমের গুরুত্ব নেই।
• কনফিগারেশন পাথ এবং এক্সিকিউশন মোডের জন্য সাধারণত ব্যবহৃত হয়।

ব্যবহারিক উদাহরণ: লগিং সহ ফাইল প্রসেসিং টুল

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.

এই কৌশলগুলোর সাহায্যে, আপনি আত্মবিশ্বাসের সাথে কমান্ড-লাইন আর্গুমেন্টের উপর নির্ভরশীল জাভা প্রোগ্রামগুলো তৈরি, পরীক্ষা এবং ডিবাগ করতে পারবেন, যা উন্নয়ন এবং প্রোডাকশন পরিবেশের মধ্যে সামঞ্জস্যপূর্ণ আচরণ নিশ্চিত করবে।