Java method — overloading, varargs আর pass-by-value

১ · Method — নাম দেওয়া একটি রেসিপি

পর্ব ১১ পর্যন্ত আপনার সব কোড ছিল main-এর ভেতরে। ছোট প্রোগ্রামে এতে সমস্যা নেই। কিন্তু একটি দোকানের বিলিং প্রোগ্রাম ভাবুন — দশ জায়গায় VAT হিসাব হয়, পাঁচ জায়গায় টাকা থেকে ডলার। একই তিন লাইন দশবার কপি করলে কী হয়? VAT-এর হার বদলালে দশ জায়গায় বদলাতে হবে, আর একটি জায়গা ভুলে গেলেই হিসাব গরমিল।

সমাধান: কাজটিকে একবার লিখে একটি নাম দিন, তারপর যতবার দরকার নাম ধরে ডাকুন। Java-তে এই নাম দেওয়া কাজের টুকরোকে বলে method. C বা Python-এ একে বলে function; Java-তে প্রতিটি function কোনো না কোনো class-এর ভেতরে থাকে, তাই নাম method.

একটি method-এর শরীরের প্রতিটি অংশ দেখুন:

static double addVat(double price, double rate) {
    double vat = price * rate;
    return price + vat;
}

ডাকার সময় বন্ধনীর ভেতরে যে মান দেন, তাকে বলে argument: addVat(1000, 0.15)-এ 1000 আর 0.15. Parameter হলো রেসিপিতে লেখা “চাল — কত কেজি”; argument হলো আজ আপনি আসলে কত কেজি দিলেন। শব্দ দুটি প্রায়ই গুলিয়ে ফেলা হয়, কিন্তু পার্থক্যটা অংশ ৭-এ খুব কাজে লাগবে।

Signature — compiler method চেনে কী দিয়ে

Java-তে একটি method-এর পরিচয় হলো তার নাম আর parameter-গুলোর টাইপের ক্রম — একে বলে method signature. ওপরের method-এর signature হলো addVat(double, double). খেয়াল করুন, তিনটি জিনিস signature-এর অংশ নয়: return type, parameter-এর নাম (price না p, তাতে কিছু যায় আসে না), আর static-এর মতো modifier. এই তথ্যটিই অংশ ৪-এ overloading-এর নিয়ম ঠিক করে দেবে।

নাম রাখার রীতি — ক্রিয়াপদ, camelCase

Method কিছু করে, তাই তার নাম সাধারণত একটি ক্রিয়াপদ দিয়ে শুরু হয়: addVat, calculateGpa, printReceipt, convertToDollar. হ্যাঁ/না উত্তর দিলে is বা has দিয়ে: isPassed, hasDiscount. লেখার রীতি camelCase — প্রথম শব্দ ছোট হাতের, পরের প্রতিটি শব্দের প্রথম অক্ষর বড়। Add_VAT বা addvat লিখলেও compile হবে, কিন্তু যেকোনো Java দলের code review-তে আটকে যাবে।

২ · return, void আর local variable

return statement দুটি কাজ করে একসাথে: একটি মান ডাকার জায়গায় পাঠায়, আর method-কে সেই মুহূর্তে শেষ করে। return-এর পরের লাইন আর চলে না। void method-এ মান ছাড়া শুধু return; লিখে আগেভাগে বের হওয়া যায়, আর শেষ লাইনে পৌঁছালে এমনিতেই শেষ হয়।

Java-র compiler এখানে কড়া পাহারাদার। যে method double ফেরত দেওয়ার প্রতিশ্রুতি দিয়েছে, তার প্রতিটি সম্ভাব্য পথে একটি return থাকতেই হবে। নিচের GPA method-টি দেখতে ঠিকঠাক, কিন্তু compile হয় না:

static double gradePoint(int marks) {
    if (marks >= 80) return 4.0;
    else if (marks >= 70) return 3.5;
    else if (marks >= 60) return 3.0;
}   // ৬০-এর কম হলে কী ফেরত যাবে?

Main.java:6: error: missing return statement
    }
    ^
1 error

Compiler বলছে: “marks যদি ৫৫ হয়, তাহলে তিনটি শর্তই মিথ্যা, আর তখন কিছুই ফেরত যায় না।” মানুষ ভাবে “এমন নম্বর তো আসবে না”; compiler ভাবে “আসতে পারে, তাই প্রমাণ দাও।” সমাধান — শেষে একটি else return 0.0; বা শুধু return 0.0;. এই কড়াকড়ি বিরক্তিকর মনে হতে পারে, কিন্তু C-তে একই ভুলে প্রোগ্রাম নীরবে আবর্জনা মান ফেরত দেয় (undefined behavior) — Java সেটা চলার আগেই আটকায়।

আরও দুটি সম্পর্কিত error, যা নতুনরা প্রায়ই দেখেন (সবগুলো Wandbox-এর OpenJDK 21-এ যাচাই করা):

Local variable আর scope

Method-এর ভেতরে ঘোষণা করা ভ্যারিয়েবল — যেমন ওপরের vat — হলো local variable. এটি শুধু ওই method-এর, বাইরে থেকে দেখা যায় না। কোন অংশ থেকে একটি নাম দেখা যায়, তাকে বলে scope: local variable-এর scope তার ঘোষণার লাইন থেকে যে block-এ সে আছে, তার শেষ } পর্যন্ত। main-এ int sub = 5; লিখে অন্য method থেকে sub পড়তে গেলে javac বলে cannot find symbol.

এর একটি সুন্দর ফল আছে: দুটি আলাদা method-এ একই নাম total রাখলে কোনো সংঘর্ষ নেই। প্রতিটি method নিজের ঘরে কাজ করে। আর Java-র আরেকটি নিয়ম, যা C-তে নেই — local variable-এর কোনো ডিফল্ট মান নেই। মান না দিয়ে পড়লে compile error, যাতে ভুল করে “আবর্জনা” পড়া অসম্ভব হয়।

৩ · Call stack — প্রতিটি ডাকের নিজের খাতা

একটি method আরেকটিকে ডাকে, সেটি আবার আরেকটিকে। JVM কীভাবে মনে রাখে কে কাকে ডেকেছে, আর কাজ শেষে কোথায় ফিরতে হবে? পর্ব ০৫-এ দেখেছিলেন, প্রতিটি thread-এর একটি নিজস্ব stack থাকে। এই stack-কেই বলে call stack. প্রতিটি method-ডাকের জন্য এতে একটি নতুন খাতা খোলে — একে বলে stack frame. খাতায় থাকে সেই ডাকের parameter, local variable, আর কাজ শেষে কোন লাইনে ফিরতে হবে সেই তথ্য।

নিচে main ডাকছে total-কে, আর total ডাকছে addVat-কে। “পরে” চাপুন — প্রতিটি ধাপে stack-এ কোন frame আছে আর কোন ভ্যারিয়েবল বেঁচে আছে, দেখুন:

1static double addVat(double amount) {2    double vat = amount * 0.15;3    return amount + vat;4}5static double total(double price, int qty) {6    double sub = price * qty;7    return addVat(sub);8}9public static void main(String[] args) {10    double bill = total(400, 2);11    System.out.println(bill);12}

এই ছবিটি মাথায় রাখলে তিনটি জিনিস একসাথে বোঝা যায়। (১) Local variable কেন return-এর পর হারিয়ে যায় — তার খাতাটাই নেই। (২) একই নামের local variable দুটি method-এ কেন সংঘর্ষ করে না — আলাদা খাতা। (৩) Exception হলে যে stack trace ছাপা হয় (at Main.addVat(...), at Main.total(...), at Main.main(...)), সেটা আসলে এই stack-এর ছবি, ওপর থেকে নিচে। পর্ব ২৯-এ exception শেখার সময় এটা আবার কাজে লাগবে।

৪ · Overloading — এক নাম, ভিন্ন parameter-তালিকা

বেশিরভাগ পণ্যে VAT ১৫%, কিন্তু কিছু পণ্যে ৫% বা ৭.৫%. দুটি আলাদা নাম রাখবেন — addVat আর addVatWithRate? Java-তে দরকার নেই। একই নামে দুটি method রাখা যায়, যদি তাদের parameter-তালিকা আলাদা হয়। একে বলে method overloading. Parameter-এর সংখ্যা আলাদা হতে পারে, টাইপ আলাদা হতে পারে, বা টাইপের ক্রম।

নিচের প্রোগ্রামে overloaded VAT method, যত খুশি দামের যোগফল (varargs — অংশ ৫-এ ব্যাখ্যা), আর টাকা থেকে ডলার রূপান্তর একসাথে আছে। চালিয়ে দেখুন:

class Main {
    static double addVat(double price) {
        return addVat(price, 0.15);           // সাধারণ হার ১৫%
    }
    static double addVat(double price, double rate) {
        return price + price * rate;
    }
    static double sum(double... prices) {
        double total = 0;
        for (double p : prices) total += p;
        return total;
    }
    static double takaToDollar(double taka) {
        return taka / 120.0;                  // ধরে নেওয়া হার
    }
    public static void main(String[] args) {
        System.out.printf("VAT 15%%: %.2f%n", addVat(1000));
        System.out.printf("VAT 5%% : %.2f%n", addVat(1000, 0.05));
        System.out.printf("Mot     : %.2f%n", sum(250, 120.5, 80));
        System.out.printf("Khali   : %.2f%n", sum());
        System.out.printf("Dollar  : %.2f%n", takaToDollar(addVat(sum(500, 700))));
    }
}

শুধু return type আলাদা হলে overload হয় না

static int    parse(String s) { … }
static double parse(String s) { … }

Main.java:9: error: method parse(String) is already defined in class Main
    static double parse(String s) { return 1.0; }
                  ^

কারণ অংশ ১-এর signature: return type signature-এর অংশ নয়, তাই compiler-এর চোখে দুটিই parse(String) — একই method দুবার। আরেকভাবে ভাবুন: parse("42"); লিখে ফল কোথাও না রাখলে compiler কীভাবে বুঝবে কোনটা চান? ডাকার জায়গায় argument দেখা যায়, ফল কোথায় যাবে তা সবসময় দেখা যায় না। তাই আলাদা ফল চাইলে আলাদা নাম — Java-র নিজের library-ও তাই করে: Integer.parseInt, Double.parseDouble. একই কারণে শুধু parameter-এর নাম বদলালেও (addVat(double p) বনাম addVat(double price)) overload হয় না।

৫ · Varargs — যত খুশি argument

একজন খদ্দের দুটি জিনিস কিনলেন, আরেকজন সাতটি। যোগফলের method-এ কয়টি parameter রাখবেন? sum(double a, double b), sum(double a, double b, double c)… এভাবে অসীম overload লেখা অসম্ভব। Java 5 থেকে এর সমাধান varargs (variable-length arguments): টাইপের পরে তিনটি বিন্দু।

static double sum(double... prices) {   // prices আসলে একটি double[]
    double total = 0;
    for (double p : prices) total += p;
    return total;
}

sum();                    // prices.length == 0
sum(250);                 // 1টি
sum(250, 120.5, 80);      // 3টি
sum(new double[] {1, 2}); // আগে থেকে বানানো array-ও দেওয়া যায়

ভেতরের রহস্য সহজ: compiler ডাকার জায়গায় argument-গুলো দিয়ে একটি array বানিয়ে পাঠায়। Method-এর ভেতরে prices একটি সাধারণ double[] — prices.length, prices[0] সব চলে (array-র পূর্ণ আলোচনা পরের পর্বে)। কোনো argument না দিলে আসে শূন্য দৈর্ঘ্যের array, null নয় — তাই ওপরের লুপ নিরাপদে 0 ফেরত দেয়।

Varargs-এর তিন নিয়ম

• একটি method-এ বড়জোর একটি varargs parameter. দুটি থাকলে compiler বুঝবে না কোন argument কোন দলে।
• সেটি থাকতে হবে সবার শেষে। printBill(String shop, double... prices) ঠিক আছে; printBill(double... prices, String shop) compile error — কারণ কোথায় দাম শেষ আর দোকানের নাম শুরু, তা নির্ধারণ করা যায় না।
• Overload বাছাইয়ে varargs সবার শেষে বিবেচিত হয়। অন্য কোনো method মিললে varargs-ওয়ালাটি জেতে না — পরের অংশে দেখবেন।

আপনি varargs আগে থেকেই ব্যবহার করছেন, হয়তো না জেনে: System.out.printf(String format, Object... args) আর String.format দুটিই varargs method. তাই printf("%s %d", name, age)-এ যত খুশি মান দেওয়া যায়।

৬ · Compiler কোনটা বেছে নেয় — overload resolution

Argument-এর টাইপ সবসময় কোনো overload-এর সাথে হুবহু মেলে না। একটি byte পাঠালেন, অথচ print(byte) নেই — আছে print(int), print(long), print(Integer) আর print(Object). কোনটা চলবে? এই বাছাইয়ের নাম overload resolution, আর Java এটা করে তিনটি ধাপে (Java Language Specification-এর §15.12.2):

যে ধাপে প্রথম কোনো প্রার্থী পাওয়া যায়, খোঁজ সেখানেই থামে — পরের ধাপের প্রার্থী যত “কাছের” মনে হোক। আর এক ধাপে একাধিক প্রার্থী থাকলে জেতে সবচেয়ে নির্দিষ্টটি (int আর long দুটিই মিললে int, কারণ int সবসময় long-এ যেতে পারে, উল্টোটা নয়)। Autoboxing মানে primitive-কে তার wrapper class-এর object-এ নিজে থেকে মুড়ে দেওয়া (পর্ব ০৬)। নিচের ডায়াগ্রামে প্রতিটি ধাপে আগে নিজে অনুমান করুন, তারপর “পরে” চাপুন:

1static void print(int x)     { … }2static void print(long x)    { … }3static void print(Integer x) { … }4static void print(Object x)  { … }5byte b = 10;6print(b);7print(5);

একই নিয়মে varargs-ও সবার শেষে আসে: print(Object) আর print(int...) থাকলে print(5) যায় print(Object)-এ (ধাপ ২-এর boxing, varargs-এর আগে), কিন্তু print() বা print(1, 2) যায় varargs-এ, কারণ অন্য কেউ মেলে না।

৭ · Pass-by-value — Java সবসময় কপি পাঠায়

এবার এই পর্বের সবচেয়ে জরুরি, আর Java দুনিয়ায় সবচেয়ে বেশি ভুল বোঝা বিষয়। নিয়মটি এক লাইনের: Java সবসময় pass by value — argument-এর মানের একটি কপি parameter-এ যায়। ব্যতিক্রম নেই। বিভ্রান্তি আসে একটি প্রশ্ন থেকে: object-এর ক্ষেত্রে “মান” জিনিসটা কী?

পর্ব ০৫-এ দেখেছেন, object থাকে heap-এ, আর ভ্যারিয়েবলে থাকে শুধু তার reference — অনেকটা ঠিকানার মতো। StringBuilder name ভ্যারিয়েবলের “মান” তাই object নয়, ঠিকানাটি। Method ডাকলে সেই ঠিকানাটিই কপি হয়। এর তিনটি ফল আছে, আর তিনটিই একটি প্রোগ্রামে দেখা যাক:

class Main {
    static void makeBigger(int n) {
        n = n * 10;                          // শুধু কপিটা বদলাল
    }
    static void addTitle(StringBuilder name) {
        name.insert(0, "Dr. ");              // একই object-এর ভেতরে বদল
    }
    static void replace(StringBuilder name) {
        name = new StringBuilder("Keu na");  // শুধু local কপি নতুন object দেখাল
    }
    static void swap(Integer a, Integer b) {
        Integer t = a; a = b; b = t;
    }
    public static void main(String[] args) {
        int price = 50;
        makeBigger(price);
        StringBuilder name = new StringBuilder("Rahima");
        addTitle(name);
        replace(name);
        Integer x = 1, y = 2;
        swap(x, y);
        System.out.println("price = " + price);
        System.out.println("name  = " + name);
        System.out.println("x = " + x + ", y = " + y);
    }
}

তিনটি ঘটনা পাশাপাশি দেখলে ছবিটা পরিষ্কার হয়। প্রতিটি ঘটনার দুটি ধাপ — ডাকের মুহূর্তে, আর parameter বদলানোর পরে:

main-এর frame          makeBigger-এর frame
┌──────────────┐        ┌──────────────┐
│ price = 50   │ ──কপি──▶│ n = 50       │
└──────────────┘        └──────────────┘
দুটি আলাদা বাক্স, দুটিতেই 50

main-এর frame          makeBigger-এর frame
┌──────────────┐        ┌──────────────┐
│ price = 50   │         │ n = 500      │
└──────────────┘        └──────────────┘
শুধু কপি বদলাল; return-এ n মুছে যাবে

stack                        heap
main:     name ──────┐
                     ├──▶ [ StringBuilder: "Rahima" ]
addTitle: name ──────┘
ঠিকানা কপি হয়েছে — দুটি তীর, একটিই object

stack                        heap
main:     name ──────┐
                     ├──▶ [ StringBuilder: "Dr. Rahima" ]
addTitle: name ──────┘
object-এর ভেতরটা বদলাল — main-ও তা-ই দেখে

stack                        heap
main:    name ──────┐
                    ├──▶ [ StringBuilder: "Dr. Rahima" ]
replace: name ──────┘
শুরুটা ঘটনা ২-এর মতোই

stack                        heap
main:    name ─────────▶ [ StringBuilder: "Dr. Rahima" ]
replace: name ─────────▶ [ StringBuilder: "Keu na" ]
শুধু replace-এর তীর ঘুরল; main-এর তীর আগের জায়গায়

যে swap কাজ করে না

“দুটি ভ্যারিয়েবলের মান অদলবদল করার একটি method লিখুন” — C++-এ void swap(int& a, int& b) দিয়ে এটা সহজ। Java-তে সম্ভবই নয়, primitive হোক বা object. ওপরের swap(Integer a, Integer b) ঘটনা ৩-এর মতোই: a = b শুধু local কপিতে নতুন ঠিকানা বসায়। আর Integer হলো immutable — তার ভেতরের মান বদলানোর কোনো method-ই নেই, তাই ঘটনা ২-এর পথও বন্ধ। Java-তে অদলবদল করতে হয় যেখানে মান থাকে সেখানেই — যেমন একটি array-র দুটি ঘর (arr[i] আর arr[j]), বা একটি object-এর দুটি field, অথবা method থেকে নতুন মান return করে।

৮ · Recursion — নিজেকেই ডাকা

একটি method নিজেকেও ডাকতে পারে — একে বলে recursion. শর্ত দুটি: (১) প্রতিটি ডাকে সমস্যা একটু ছোট হবে, (২) একটি সবচেয়ে ছোট অবস্থা থাকবে, যেখানে আর না ডেকে সরাসরি উত্তর দেওয়া যায় — একে বলে base case. ক্লাসিক উদাহরণ factorial: ৩! = ৩ × ২!, আর ১! = ১.

static long factorial(int n) {
    if (n <= 1) return 1;              // base case
    return n * factorial(n - 1);       // ছোট সমস্যা, নিজেকে দিয়ে
}

অংশ ৩-এর call stack-ই এখানে চাবি। প্রতিটি ডাক নিজের frame পায়, নিজের n পায় — তাই একসাথে তিনটি আলাদা n বেঁচে থাকতে পারে:

1static long factorial(int n) {2    if (n <= 1) return 1;3    return n * factorial(n - 1);4}

Base case ভুলে গেলে — StackOverflowError

নিচের কোডে base case নেই। javac কোনো আপত্তি করে না — অসীম recursion ধরা compiler-এর কাজ নয়। কিন্তু চালালে:

class Main {
    static long factorial(int n) {
        return n * factorial(n - 1);   // base case নেই!
    }

    public static void main(String[] args) {
        System.out.println(factorial(5));
    }
}

Exception in thread "main" java.lang.StackOverflowError
	at Main.factorial(Main.java:3)
	at Main.factorial(Main.java:3)
	at Main.factorial(Main.java:3)
	... (একই লাইন শত শত বার)

n চলে গেল 5, 4, … 0, −1, −2 … প্রতিটি ডাক একটি নতুন frame. Thread-এর stack-এর জায়গা সীমিত (সাধারণত এক মেগাবাইটের কাছাকাছি, JVM ও অপারেটিং সিস্টেমভেদে আলাদা), তাই হাজার হাজার ডাকের পর জায়গা ফুরিয়ে যায় আর JVM ছোড়ে StackOverflowError. Stack trace-এ একই লাইন বারবার দেখলেই বুঝবেন: থামার শর্ত নেই, বা শর্তে কখনো পৌঁছানো যাচ্ছে না।

৯ · ভালো method — Javadoc, pure method আর একটি কাজ

Javadoc — method-এর ব্যবহারবিধি

Method-এর ঠিক ওপরে /** … */ দিয়ে লেখা comment হলো Javadoc. এতে লেখা হয় method কী করে, প্রতিটি parameter কী (@param), আর কী ফেরত দেয় (@return). IntelliJ বা VS Code-এ method-এর নামের ওপর মাউস রাখলেই এই লেখা ভেসে ওঠে, আর javadoc টুল এখান থেকে HTML ডকুমেন্টেশন বানায় — Java-র নিজের সব API ডকুমেন্টেশন এভাবেই তৈরি।

/**
 * দামের সাথে VAT যোগ করে মোট দাম ফেরত দেয়।
 *
 * @param price VAT ছাড়া দাম, টাকায়; ঋণাত্মক হবে না
 * @param rate  VAT-এর হার, যেমন 0.15 মানে ১৫ শতাংশ
 * @return VAT-সহ মোট দাম
 */
static double addVat(double price, double rate) {
    return price + price * rate;
}

ভালো Javadoc বলে কোড পড়ে যা বোঝা যায় না: একক (টাকা না পয়সা?), সীমা (ঋণাত্মক চলবে?), আর হারটি ১৫ না ০.১৫ আকারে দিতে হবে। “@param price the price” ধরনের লেখা কোনো তথ্য দেয় না — সেটা না লেখাই ভালো।

Pure method বনাম side effect

addVat-এর ফল শুধু তার argument-এর ওপর নির্ভর করে, আর সে বাইরের কিছু বদলায় না, কিছু ছাপেও না। একই input দিলে হাজারবার একই output. এমন method-কে বলে pure method. উল্টো দিকে, যে method স্ক্রিনে ছাপে, ফাইলে লেখে, argument-এর object বদলায় (অংশ ৭-এর addTitle), সে side effect তৈরি করে।

Side effect খারাপ নয় — প্রোগ্রাম কিছু ছাপে না বা সেভ না করলে তার কোনো মূল্যই নেই। কিন্তু হিসাব আর side effect এক method-এ মিশিয়ে ফেললে সমস্যা। calculateAndPrintGpa() পরীক্ষা করতে হলে স্ক্রিনের লেখা ধরতে হয়; calculateGpa() শুধু একটি সংখ্যা ফেরত দিলে এক লাইনে যাচাই করা যায়: ফল কি 3.75? পর্ব ৪৭-এ JUnit দিয়ে ঠিক এভাবেই টেস্ট লিখবেন। নিয়ম: হিসাব করুন pure method-এ, ছাপুন বা সেভ করুন আলাদা, পাতলা method-এ।

কত বড় হবে একটি method?

কোনো নির্দিষ্ট লাইন-সংখ্যা নেই, কিন্তু কয়েকটি সংকেত আছে। Method-এর কাজ এক বাক্যে বলতে গিয়ে যদি “এবং” লাগে (“ইনপুট নেয় এবং হিসাব করে এবং রসিদ ছাপে”), তাহলে সেটা তিনটি method. Method-এর ভেতরে comment দিয়ে ভাগ করা অংশ (// step 2: discount) প্রায়ই বলে দেয় যে সেই অংশটি নিজেই একটি method হতে চায় — আর comment-টিই তার নাম। পাঁচ-ছয়টির বেশি parameter হলে ভাবুন, এগুলো একসাথে কোনো object বা record হওয়া উচিত কি না (পর্ব ২৫)।

১০ · AI-এর যুগে — method-এর চুক্তি যাচাই করা আপনার কাজ

AI-কে “একটি বিলিং প্রোগ্রাম লিখে দাও” বললে সে প্রায়ই একটি দুশো লাইনের main দেয়, অথবা চমৎকার দেখতে কিছু method — যার একটির ভেতরে ইনপুট, হিসাব, ছাপা সব মেশানো। কোড চলে, কিন্তু পড়া, বদলানো আর টেস্ট করা কঠিন। আর ধারণাগত প্রশ্নে (“Java-তে object কীভাবে পাস হয়?”) অনেক AI এখনো ইন্টারনেটের পুরোনো, ভুল বাক্যটি আওড়ায়।

AI-এর লেখা method হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি method-এর কাজ “এবং” ছাড়া এক বাক্যে বলতে পারি
• হিসাবের method-গুলো কিছু ছাপে না — হাতে হিসাব করা একটি উদাহরণের সাথে ফল মিলিয়েছি
• কোনো method parameter-এ নতুন মান বসিয়ে আশা করছে না যে caller-এর ভ্যারিয়েবল বদলাবে
• Overload থাকলে প্রতিটি ডাক কোন সংস্করণে যাচ্ছে, তা নিশ্চিত — দরকারে একটি println দিয়ে দেখেছি
• Recursion থাকলে base case আছে, আর বড় input-এ StackOverflowError আসবে কি না ভেবেছি
• Javadoc-এ একক আর সীমা লেখা আছে, আর তা কোডের আচরণের সাথে মেলে