মাঝপথের প্রজেক্ট — “হিসাব খাতা” CLI টুল

১ · কেন একটি প্রজেক্ট — “হিসাব খাতা”-র চাহিদা

গত বিশটি পর্বে আপনি অনেক টুকরো শিখেছেন: class আর object, constructor, private field, static আর final, inheritance, polymorphism, interface, array, Scanner, switch expression. প্রতিটি টুকরো আলাদাভাবে বোঝা এক জিনিস। কিন্তু একটি আসল প্রোগ্রামে এগুলো একসাথে কাজ করে, আর তখন নতুন প্রশ্ন আসে: কোন কাজ কোন class-এর? কোথায় ভুল ইনপুট আটকাব? নতুন feature যোগ করলে কতটা কোড বদলাতে হবে? এই প্রশ্নগুলোর উত্তর কোনো একক পর্বে শেখানো যায় না — বানাতে বানাতে শিখতে হয়।

চাহিদা — কমান্ডের টেবিল

কোড লেখার আগে লিখে ফেলুন, টুলটি ঠিক কী করবে। আমাদের “হিসাব খাতা” পাঁচটি কমান্ড বোঝে:

নিয়মগুলোও লিখে রাখুন, কারণ পরে এগুলোই টেস্টের তালিকা হবে: (১) টাকা হবে ধনাত্মক পূর্ণসংখ্যা — পয়সার হিসাব এই সংস্করণে নেই। (২) খাত চারটির একটি: food, transport, bill, other. (৩) খাতায় জায়গা নির্দিষ্ট; ভরে গেলে টুল পরিষ্কার জানাবে। (৪) অজানা কমান্ড বা ভুল টাকায় টুল ভেঙে পড়বে না, একটি বোধগম্য বার্তা দিয়ে পরের কমান্ডের জন্য অপেক্ষা করবে।

কী বানাব না — পরিধির সীমা

নতুনদের প্রজেক্ট সবচেয়ে বেশি ডোবে পরিধি বাড়তে বাড়তে। তাই সচেতনভাবে ঠিক করুন কী বাদ: ফাইলে সেভ করা নেই (পর্ব ৩৭), তারিখ নেই (পর্ব ৩৮), ArrayList নেই (পর্ব ৩০), পয়সা নেই, মাঝের কোনো খরচ মুছে ফেলা নেই। যা থাকবে, তা পুরোপুরি কাজ করবে। ছোট কিন্তু সম্পূর্ণ, চালিয়ে দেখা যায় এমন প্রথম সংস্করণকে বলে MVP (minimum viable product).

২ · নকশা — বিশেষ্য, ক্রিয়া, CRC কার্ড আর একটি UML ছবি

পর্ব ০২-এ শিখেছিলেন বিশেষ্য-ক্রিয়া বিশ্লেষণ: চাহিদার বাক্যে বিশেষ্যগুলো প্রায়ই class হয়, ক্রিয়াগুলো method. আমাদের চাহিদা এক বাক্যে: “ব্যবহারকারী একটি কমান্ড লিখে খাতায় একটি খাতের খরচ যোগ করেন, খরচগুলো দেখেন, মোট বের করেন, আর শেষটা বাতিল করেন।”

• বিশেষ্য → class: খরচ → Expense, খাত → Category, খাতা → ExpenseBook, কমান্ড → Command. “ব্যবহারকারী” class নয় — তিনি প্রোগ্রামের বাইরে বসে আছেন।
• ক্রিয়া → method বা আলাদা কমান্ড: যোগ করা → add, দেখা → list, মোট → total, বাতিল → undo.

CRC কার্ড — কার দায়িত্ব কী

CRC কার্ড (Class–Responsibility–Collaborator) হলো প্রতিটি class-এর জন্য একটি ছোট কার্ড: নাম, তার দায়িত্ব, আর কাজ করতে সে কাদের সাহায্য নেয় (সহযোগী). ১৯৮৯ সালে Kent Beck আর Ward Cunningham এই পদ্ধতি প্রকাশ করেন, যাতে নকশা কোডের আগেই টেবিলে বসে আলোচনা করা যায়।

লক্ষ করুন, কোনো কার্ডে “সব কিছু” লেখা নেই। প্রতিটি class একটি স্পষ্ট কাজ করে — একে বলে উঁচু cohesion. উল্টোটা হলো god class: একটি Main যে পড়ে, যাচাই করে, রাখে, হিসাব করে, ছাপে। ছোট প্রোগ্রামে god class চলে যায়, কিন্তু প্রতিটি নতুন feature তাকে আরও জট পাকায়।

UML class diagram — লেখায় আঁকা ছবি

CRC কার্ড বলে কে কী করে; UML class diagram দেখায় class-গুলোর মধ্যে সম্পর্ক। কাগজ-কলমেই আঁকা যায়, এখানে লেখা দিয়ে আঁকা হলো:

┌──────────────────────┐        ┌───────────────────────┐
│ ExpenseBook          │ has-a  │ Expense  (immutable)  │
│ - items : Expense[]  │◆──────▶│ - category : String   │
│ - count : int        │  0..n  │ - amount   : int      │
│ + add(e) : boolean   │        │ - note     : String   │
│ + removeLast()       │        │ + Expense(c, a, n)    │──▶ Category.isValid()
│ + total(cat) : int   │        └───────────────────────┘
└──────────▲───────────┘
           │ ব্যবহার করে
┌──────────┴───────────────────────┐
│ «interface» Command              │
│ + name() : String                │
│ + run(book, words) : void        │
└──────────▲───────────────────────┘
           │ implements (is-a)
   ┌───────┼───────────┬──────────────┐
AddCommand ListCommand TotalCommand UndoCommand

দুই ধরনের সম্পর্ক চোখে পড়ে। ExpenseBook-এর ভেতরে Expense-এর একটি array আছে — এটা has-a সম্পর্ক (composition). আর AddCommand একটি Command — এটা is-a সম্পর্ক, যা Java-তে implements দিয়ে লেখা হয়। - চিহ্ন মানে private, + মানে বাইরে থেকে ব্যবহারযোগ্য। এই ছবিটিই পুরো প্রজেক্টের মানচিত্র — কোডে হারিয়ে গেলে এখানে ফিরে আসবেন।

৩ · বড় সিদ্ধান্ত — switch দিয়ে বাছাই, নাকি Command interface?

লাইনটি পড়ার পর প্রোগ্রামকে ঠিক করতে হবে কোন কাজ চলবে। পর্ব ১০-এর switch expression দিয়ে এটা সবচেয়ে সরলভাবে করা যায়:

// বিকল্প ক — এক জায়গায় বাছাই, প্রতিটি কাজ একটি static method
String reply = switch (words[0]) {
    case "add"   -> add(book, words);
    case "list"  -> list(book);
    case "total" -> total(book, words);
    case "undo"  -> undo(book);
    default      -> "error: unknown command " + words[0];
};

দ্বিতীয় বিকল্প পর্ব ২০–২১-এর polymorphism কাজে লাগায়: প্রতিটি কমান্ড একটি আলাদা class, সবাই একটি interface মানে।

// বিকল্প খ — প্রতিটি কমান্ড নিজেই একটি object
interface Command {
    String name();
    void run(ExpenseBook book, String[] words);
}
// main loop শুধু বলে: "যে-ই হও, run করো"
Command cmd = find(words[0]);
cmd.run(book, words);

সৎ উত্তর: চারটি কমান্ডের টুলে বিকল্প ক মোটেও ভুল নয়, বরং অনেক পেশাদার এটিই লিখতেন। আমরা বিকল্প খ বেছে নিচ্ছি দুটি কারণে। প্রথমত, এই পর্বের উদ্দেশ্য পর্ব ২০–২১-এর ধারণাগুলো একটি বাস্তব জায়গায় কাজ করতে দেখা। দ্বিতীয়ত, কমান্ডকে object বানানো একটি প্রতিষ্ঠিত নকশা — Command pattern — যার ওপর ভবিষ্যতে undo-history বা স্ক্রিপ্ট চালানো সহজে বসানো যায় (ভাবনার প্রশ্ন ২)। নতুন কমান্ড এলে পুরোনো কোড না ছুঁয়ে শুধু নতুন class যোগ করা — একে বলে open/closed principle: বাড়ানোর জন্য খোলা, বদলানোর জন্য বন্ধ।

এই নকশায় পৌঁছানো এক লাফে হয় না। একটি নতুন প্রোগ্রামার যেভাবে ধাপে ধাপে এখানে আসেন, নিচে দেখুন — প্রতিটি ধাপে কোন সমস্যা পরের ধাপকে বাধ্য করল, সেটা খেয়াল করুন:

String[] cats = new String[100];
int[] amounts = new int[100];       // দুটি সমান্তরাল array
int n = 0;
while (in.hasNextLine()) {
    String[] w = in.nextLine().split(" ");
    if (w[0].equals("add")) { cats[n] = w[1]; amounts[n] = ...; n++; }
    else if (w[0].equals("list")) { ... }
    else if (w[0].equals("total")) { ... }
    // ১৫০ লাইন পরে ...
}

static void add(String[] cats, int[] amounts, ...) { ... }
static void list(String[] cats, int[] amounts, int n) { ... }

// main ছোট হলো, কিন্তু প্রতিটি method-এ
// একই তিনটি জিনিস ঘুরছে: cats, amounts, n

final class Expense { // খাত + টাকা + নোট এক object-এ
    Expense(...) { যাচাই এখানে }
}
class ExpenseBook {   // array আর count লুকানো
    private Expense[] items; private int count;
    boolean add(Expense e) { ... }
}

interface Command { String name(); void run(...); }
class AddCommand implements Command { ... }
class ListCommand implements Command { ... }

Command cmd = find(w[0]);
cmd.run(book, w);   // main আর কখনো বদলাবে না

৪ · ধাপ ১ — Category আর Expense: যাচাই করা, অপরিবর্তনীয় ডেটা

নিচ থেকে ওপরে বানানো সবচেয়ে নিরাপদ: আগে সেই class, যে অন্য কারও ওপর নির্ভর করে না। Category-এর কাজ শুধু বৈধ খাতগুলো জানা। পর্ব ১৮-এর static final দিয়ে ধ্রুবক বানানো হলো:

final class Category {
    static final String FOOD = "food", TRANSPORT = "transport",
                        BILL = "bill", OTHER = "other";
    static final String[] ALL = {FOOD, TRANSPORT, BILL, OTHER};

    private Category() {}            // object বানানোর দরকার নেই

    static boolean isValid(String name) {
        for (String c : ALL) if (c.equals(name)) return true;
        return false;
    }
}

দুটি খুঁটিনাটি লক্ষ করুন। private constructor থাকায় কেউ new Category() লিখতে পারে না — এই class শুধু ধ্রুবক আর static method-এর আধার, যাকে বলে utility class (Java-র নিজের Math class-ও এমন)। আর তুলনা হয়েছে equals দিয়ে, == দিয়ে নয় — Scanner থেকে আসা String আর literal একই object না-ও হতে পারে (পর্ব ০৮)।

Expense — জন্মের সময়ই যাচাই

একটি খরচের তিনটি তথ্য: খাত, টাকা, নোট। মূল নকশা-সিদ্ধান্ত হলো যাচাই কোথায় হবে। উত্তর: constructor-এ। যদি constructor ভুল ডেটা পেলে object তৈরিই না করে, তাহলে প্রোগ্রামের কোথাও একটি অবৈধ Expense থাকা অসম্ভব। পর্ব ০২-এর ভাষায়, এটা class-এর invariant: “প্রতিটি Expense-এর টাকা ধনাত্মক আর খাত বৈধ” — সবসময় সত্য।

final class Expense {
    private final String category, note;
    private final int amount;                  // পূর্ণ টাকা

    Expense(String category, int amount, String note) {
        if (amount <= 0)
            throw new IllegalArgumentException("amount must be positive");
        if (!Category.isValid(category))
            throw new IllegalArgumentException("unknown category " + category);
        this.category = category;
        this.amount = amount;
        this.note = note;
    }
    String category() { return category; }    // শুধু পড়ার method, setter নেই
    int amount()      { return amount; }
    String note()     { return note; }
}

throw new IllegalArgumentException(...) লাইনটি constructor-কে মাঝপথে থামিয়ে দেয় — object তৈরি হয় না, আর একটি বার্তা ডাকার জায়গায় ফিরে যায়। IllegalArgumentException হলো Java-র নিজের “ভুল argument” সংকেত। Exception-এর পূর্ণ গল্প পর্ব ২৯-এ; এখানে শুধু দুটি জিনিস লাগবে: কীভাবে ছুড়তে হয় (ওপরে), আর অংশ ৭-এ কীভাবে একটি catch দিয়ে বার্তাটি ধরে ছাপতে হয়।

এই class immutable — তৈরি হওয়ার পর কখনো বদলায় না। তিনটি উপাদান মিলে তা নিশ্চিত করে: সব field private final, কোনো setter নেই, আর class নিজে final, যাতে কেউ subclass বানিয়ে বদলানোর মতো আচরণ ঢোকাতে না পারে। লাভ কী? undo-তে সরানো খরচ নিশ্চিন্তে ফেরত দেওয়া যায়, একই object দুই জায়গায় থাকলেও কেউ চুপচাপ বদলে দিতে পারে না, আর String-এর মতোই এটি নিয়ে ভাবা সহজ। Getter-এর নাম getAmount() না রেখে amount() রাখা হয়েছে, কারণ পর্ব ২৫-এর record ঠিক এই রীতিতে নাম দেয় — তখন পুরো class-টি এক লাইনের record হয়ে যেতে পারবে।

ধাপের শেষে প্রোগ্রাম চলে: প্রতিটি ধাপ শেষে একটি ছোট main দিয়ে যাচাই করুন — new Expense("food", 120, "cha") ঠিকঠাক তৈরি হয় কি না, আর new Expense("food", -5, "x") সত্যিই থামে কি না। পুরো টুল একবারে লিখে শেষে চালালে দশটি bug একসাথে আসে; প্রতি ধাপে চালালে আসে একটি একটি করে।

৫ · ধাপ ২ — ExpenseBook: array আর count দিয়ে খাতা

খাতায় অনেক খরচ। পর্ব ১৩-এর array-এর মাপ তৈরির সময়ই ঠিক হয়ে যায়, পরে বাড়ে না। তাই প্রচলিত কৌশল: একটি বড় array, আর একটি count — কয়টি ঘর আসলে ভরা। count একসাথে দুটি তথ্য দেয়: খাতায় কয়টি খরচ, আর পরের খরচ কোন ঘরে বসবে।

class ExpenseBook {
    private final Expense[] items;
    private int count = 0;                    // items[0..count-1] ভরা

    ExpenseBook(int capacity) { items = new Expense[capacity]; }

    boolean add(Expense e) {
        if (count == items.length) return false;   // খাতা ভরা
        items[count++] = e;
        return true;
    }
    Expense removeLast() {
        if (count == 0) return null;              // বাতিলের কিছু নেই
        Expense e = items[--count];
        items[count] = null;                      // পুরোনো reference মুছে দাও
        return e;
    }
    int size() { return count; }
    Expense get(int i) { return items[i]; }
    int total(String cat) {                       // cat == null মানে সব খাত
        int sum = 0;
        for (int i = 0; i < count; i++)
            if (cat == null || items[i].category().equals(cat)) sum += items[i].amount();
        return sum;
    }
}

এই class-এর invariant: items[0] থেকে items[count-1] পর্যন্ত প্রতিটি ঘরে একটি বৈধ Expense, বাকি সব ঘর null. array আর count দুটিই private, তাই বাইরের কেউ এই নিয়ম ভাঙতে পারে না — শুধু add আর removeLast দিয়ে খাতা বদলায়, আর দুটিই নিয়ম মেনে চলে। নিচের ডায়াগ্রামে চার ঘরের একটি খাতায় যোগ, ভরে যাওয়া, undo আর আবার যোগ দেখুন — count কীভাবে সরে, আর খালি হওয়া ঘর কীভাবে আবার ব্যবহার হয়:

1boolean add(Expense e) {2    if (count == items.length) return false;3    items[count++] = e;4    return true;5}6Expense removeLast() {7    if (count == 0) return null;8    Expense e = items[--count];9    items[count] = null;10    return e;11}

সৎ স্বীকারোক্তি: নির্দিষ্ট মাপের array-র সবচেয়ে বড় দুর্বলতা — মাপ আগে থেকে অনুমান করতে হয়। কম ধরলে খাতা ভরে যায়, বেশি ধরলে মেমরি নষ্ট। পর্ব ৩০-এর ArrayList এই কাজটাই নিজে করে: ভরে গেলে ভেতরে একটি বড় array বানিয়ে পুরোনোগুলো কপি করে নেয়। মজার ব্যাপার, তখন আমাদের শুধু ExpenseBook-এর ভেতরটা বদলাতে হবে — বাকি কোনো class জানেই না খাতার ভেতরে array না ArrayList. Encapsulation-এর আসল পুরস্কার এটাই।

৬ · ধাপ ৩ — Command interface আর polymorphic dispatch

এবার কমান্ডগুলো। প্রতিটি কমান্ড class Command interface মানবে — অর্থাৎ নিজের নাম বলতে পারবে, আর কাজ করতে পারবে। AddCommand সবচেয়ে বেশি কাজ করে, তাই সেটিই দেখা যাক:

interface Command {
    String name();
    void run(ExpenseBook book, String[] words);
}

class AddCommand implements Command {
    public String name() { return "add"; }
    public void run(ExpenseBook book, String[] w) {
        if (w.length < 3) { System.out.println("usage: add <category> <amount> [note]"); return; }
        Expense e = new Expense(w[1], Integer.parseInt(w[2]), w.length > 3 ? w[3] : "-");
        System.out.println(book.add(e) ? "ok, saved #" + book.size() : "error: book is full");
    }
}

Interface-এর method গুলো স্বয়ংক্রিয়ভাবে public, তাই implement করার সময়ও public লিখতে হয় — না লিখলে compiler আপত্তি করে, কারণ override করার সময় access কমানো যায় না (পর্ব ১৯)। AddCommand নিজে কিছু যাচাই করে না: টাকা সংখ্যা কি না, তা দেখে Integer.parseInt, আর খাত ও ধনাত্মকতা দেখে Expense-এর constructor. প্রতিটি নিয়ম এক জায়গায় — একে বলে দায়িত্বের পরিষ্কার ভাগ।

সঠিক কমান্ড খোঁজা

নাম থেকে কমান্ড খুঁজতে আমরা একটি সাধারণ array আর loop ব্যবহার করব (নাম থেকে মান খোঁজার আসল কাঠামো Map আসবে পর্ব ৩১-এ)। সব কমান্ড object একটি Command[]-এ থাকে — array-র টাইপ interface, কিন্তু ভেতরের object-গুলো চার ভিন্ন class-এর। এটাই polymorphism-এর হৃদয়: একটি ভ্যারিয়েবল টাইপ, অনেক আসল আকার। total লিখলে কী ঘটে, ধাপে ধাপে দেখুন:

1static final Command[] COMMANDS = {new AddCommand(),2    new ListCommand(), new TotalCommand(), new UndoCommand()};3static Command find(String name) {4    for (Command c : COMMANDS)5        if (c.name().equals(name)) return c;6    return null;7}8Command cmd = find(w[0]);   // w[0] = "total"9cmd.run(book, w);

কেন abstract class নয়, interface? পর্ব ২১-এর নিয়ম মনে করুন: যখন subclass-গুলোর মধ্যে ভাগ করার মতো field বা কোড থাকে, তখন abstract class. আমাদের কমান্ডগুলোর কোনো সাধারণ অবস্থা নেই — শুধু একটি চুক্তি: “নাম বলো, কাজ করো।” চুক্তির জন্য interface সঠিক হাতিয়ার, আর একটি class একাধিক interface মানতে পারে, কিন্তু একটির বেশি class extend করতে পারে না।

৭ · ধাপ ৪ — পুরো প্রোগ্রাম: একটি লাইনের যাত্রা

সব টুকরো তৈরি। এখন main — যে Scanner দিয়ে লাইন পড়ে, ভাগ করে, কমান্ড খোঁজে, কাজ দেয়, আর ভুল হলে বার্তা ছাপে। পুরো কোড দেখার আগে একটি লাইন add food 120 cha singara-কে টুলের ভেতর দিয়ে অনুসরণ করুন:

String line = in.nextLine().trim();
line == "add food 120 cha singara"

w[0] = "add"
w[1] = "food"
w[2] = "120"
w[3] = "cha singara"   // নোটের ফাঁকা জায়গা অক্ষত

Command cmd = find("add");
// cmd-এর আসল class: AddCommand
cmd.run(book, w);

Integer.parseInt("120")        → 120
new Expense("food", 120, "cha singara")  // যাচাই পাস
book.add(e)  → items[0] = e, count = 1

> add food 120 cha singara
ok, saved #1

এবার পুরো টুলটি এক ফাইলে। লম্বা — Java-তে আটটি class আর একটি interface জায়গা নেয় — কিন্তু প্রতিটি অংশ আপনি আগেই দেখেছেন। “চালান” চাপলে নিচের স্ক্রিপ্ট করা ইনপুট দিয়ে পুরো একটি সেশন চলবে:

import java.util.Scanner;

final class Category {
    static final String[] ALL = {"food", "transport", "bill", "other"};
    private Category() {}
    static boolean isValid(String c) {
        for (String k : ALL) if (k.equals(c)) return true;
        return false;
    }
}
final class Expense {
    private final String category, note;
    private final int amount;
    Expense(String category, int amount, String note) {
        if (amount <= 0) throw new IllegalArgumentException("amount must be positive");
        if (!Category.isValid(category)) throw new IllegalArgumentException("unknown category " + category);
        this.category = category; this.amount = amount; this.note = note;
    }
    String category() { return category; }
    int amount() { return amount; }
    String note() { return note; }
}
class ExpenseBook {
    private final Expense[] items;
    private int count = 0;
    ExpenseBook(int capacity) { items = new Expense[capacity]; }
    boolean add(Expense e) {
        if (count == items.length) return false;
        items[count++] = e; return true;
    }
    Expense removeLast() {
        if (count == 0) return null;
        Expense e = items[--count]; items[count] = null; return e;
    }
    int size() { return count; }
    Expense get(int i) { return items[i]; }
    int total(String cat) {
        int sum = 0;
        for (int i = 0; i < count; i++)
            if (cat == null || items[i].category().equals(cat)) sum += items[i].amount();
        return sum;
    }
}
interface Command { String name(); void run(ExpenseBook book, String[] w); }
class AddCommand implements Command {
    public String name() { return "add"; }
    public void run(ExpenseBook book, String[] w) {
        if (w.length < 3) { System.out.println("usage: add <category> <amount> [note]"); return; }
        Expense e = new Expense(w[1], Integer.parseInt(w[2]), w.length > 3 ? w[3] : "-");
        System.out.println(book.add(e) ? "ok, saved #" + book.size() : "error: book is full");
    }
}
class ListCommand implements Command {
    public String name() { return "list"; }
    public void run(ExpenseBook book, String[] w) {
        if (book.size() == 0) { System.out.println("(no expenses yet)"); return; }
        System.out.printf("%-3s %-10s %6s  %s%n", "#", "CATEGORY", "TAKA", "NOTE");
        for (int i = 0; i < book.size(); i++) {
            Expense e = book.get(i);
            System.out.printf("%-3d %-10s %6d  %s%n", i + 1, e.category(), e.amount(), e.note());
        }
    }
}
class TotalCommand implements Command {
    public String name() { return "total"; }
    public void run(ExpenseBook book, String[] w) {
        String cat = w.length > 1 ? w[1] : null;
        System.out.printf("total %s: %d tk%n", cat == null ? "all" : cat, book.total(cat));
    }
}
class UndoCommand implements Command {
    public String name() { return "undo"; }
    public void run(ExpenseBook book, String[] w) {
        Expense e = book.removeLast();
        System.out.println(e == null ? "nothing to undo" : "undone: " + e.category() + " " + e.amount());
    }
}
class Main {
    static final Command[] COMMANDS = {new AddCommand(), new ListCommand(), new TotalCommand(), new UndoCommand()};
    static Command find(String name) {
        for (Command c : COMMANDS) if (c.name().equals(name)) return c;
        return null;
    }
    public static void main(String[] args) {
        ExpenseBook book = new ExpenseBook(4);          // ছোট খাতা, যাতে "ভরা" অবস্থা দেখা যায়
        Scanner in = new Scanner(System.in);
        while (in.hasNextLine()) {
            String line = in.nextLine().trim();
            if (line.isEmpty()) continue;
            System.out.println("> " + line);              // স্ক্রিপ্ট করা সেশনে কমান্ডটি দেখানো
            String[] w = line.split("\\s+", 4);
            if (w[0].equals("quit")) break;
            Command cmd = find(w[0]);
            if (cmd == null) { System.out.println("error: unknown command " + w[0]); continue; }
            try { cmd.run(book, w); }
            catch (NumberFormatException ex) { System.out.println("error: amount must be a whole number"); }
            catch (IllegalArgumentException ex) { System.out.println("error: " + ex.getMessage()); }
        }
        System.out.printf("bye: %d expenses, %d tk%n", book.size(), book.total(null));
    }
}

৮ · হাতে টেস্ট — edge case-এর টেবিল

প্রোগ্রাম “চলছে” মানে শুধু এটুকু প্রমাণ যে আপনার ভাবা ইনপুটে চলছে। আসল প্রশ্ন: যে ইনপুট আপনি ভাবেননি, তাতে কী হয়? সীমানার কাছের বা অদ্ভুত ইনপুটকে বলে edge case. JUnit দিয়ে স্বয়ংক্রিয় টেস্ট শিখবেন পর্ব ৪৭-এ; এখন একটি টেবিল আর হাতে চালানোই যথেষ্ট। প্রতিটি সারিতে আগে প্রত্যাশা লিখুন, তারপর চালিয়ে মেলান:

লক্ষ করুন, টেবিলে চারটি ⚠ ধরা পড়ল — কোনোটিই crash নয়, কিন্তু প্রতিটি হয় বিভ্রান্তিকর বার্তা, নয়তো নীরব ভুল। নীরব ভুল সবচেয়ে বিপজ্জনক, কারণ ব্যবহারকারী টেরই পান না। এটাই Kent Beck-এর নামে প্রচলিত ক্রমের দ্বিতীয় ধাপ: আগে চালাও, তারপর ঠিক করো, তারপর দরকার হলে দ্রুত করো (ভাবনার প্রশ্ন ৩)। আমাদের টুল প্রথম ধাপ পার করেছে; টেবিলটি দ্বিতীয় ধাপের কাজের তালিকা।

৯ · নিজের কম্পিউটারে — একাধিক ফাইলের আসল প্রজেক্ট

অনলাইন runner-এ সব এক ফাইলে রাখতে হয়েছে। আসল Java প্রজেক্টে নিয়ম হলো: প্রতিটি top-level class বা interface নিজের ফাইলে, আর public class-এর ফাইলের নাম হুবহু class-এর নাম। পর্ব ০৩-এ ইনস্টল করা JDK দিয়ে একটি ফোল্ডার বানান:

hisab-khata/
├── Category.java
├── Expense.java
├── ExpenseBook.java
├── Command.java
├── AddCommand.java
├── ListCommand.java
├── TotalCommand.java
├── UndoCommand.java
└── Main.java          ← public class Main { public static void main(...) }

ফাইলগুলোর class-গুলোতে public বসাতে পারেন (public class Main, public final class Expense ইত্যাদি) — একই ফোল্ডারে থাকা class-গুলো এমনিতেও একে অপরকে দেখতে পায়, কারণ তারা একই package-এ (এখানে নামহীন default package). Main-এ দুটি ছোট বদল করুন: স্ক্রিপ্টের জন্য লাইন আবার ছাপার (println("> " + line)) বদলে লুপের শুরুতে System.out.print("> "); লিখে prompt দেখান, আর খাতার capacity ৪ থেকে বাড়িয়ে ১০০০ করুন। তারপর ফোল্ডারে terminal খুলে:

javac -d out *.java          # সব ফাইল compile, .class যাবে out ফোল্ডারে
java -cp out Main             # চালান; quit লিখে বের হোন

javac একসাথে সব ফাইল compile করে, আর প্রতিটি class-এর জন্য একটি .class ফাইল বানায় — নয়টি সোর্স ফাইল থেকে নয়টি .class. -cp out JVM-কে বলে class কোথায় খুঁজবে (পর্ব ০৩-এর classpath). একই সেশন বারবার টেস্ট করতে কমান্ডগুলো একটি session.txt ফাইলে লিখে রাখুন আর ইনপুট হিসেবে দিন — Linux/macOS terminal বা Windows-এর cmd-তে java -cp out Main < session.txt; PowerShell-এ < চলে না, সেখানে Get-Content session.txt | java -cp out Main. প্রতিবার কোড বদলের পর একই ফাইল চালিয়ে আউটপুট মিলিয়ে নেওয়া — এটাই স্বয়ংক্রিয় টেস্টের প্রথম রূপ।

jar --create --file hisab.jar --main-class Main -C out .
java -jar hisab.jar           # এক ফাইলে পুরো টুল, যেকোনো JDK-ওয়ালা কম্পিউটারে চলে

পরের ধাপ — টুলটিকে বাড়ানোর ধারণা

১০ · AI-এর যুগে — AI-কে নকশা-রিভিউয়ার বানান, লেখক নয়

এই পুরো প্রজেক্ট একটি AI-কে এক বাক্যে বললে সে কয়েক সেকেন্ডে লিখে দেবে। তাহলে নিজে বানানোর মানে কী? মানে হলো, AI-এর কোড চলবে, কিন্তু আপনি জানবেন না কেন constructor-এ যাচাই, কেন items[count] = null, কেন catch-এর এই ক্রম — আর যেদিন AI ভুল করবে, সেদিন ধরতেও পারবেন না। সঠিক ব্যবহার হলো AI-কে pair programming-এর সঙ্গী বানানো: আপনি চালক, AI পাশে বসা রিভিউয়ার। তাকে দিন আপনার নকশা আর কোড, চান সমালোচনা — পুরো সমাধান নয়।

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

• AI-এর দেওয়া প্রতিটি “ভাঙে এমন ইনপুট” নিজে চালিয়ে দেখেছি — সত্যিই ভাঙে কি না
• যে পরামর্শ বুঝিনি, তা কোডে বসাইনি; আগে AI-কে কারণ ব্যাখ্যা করতে বলেছি
• পরামর্শে এমন কিছু নেই যা আমি এখনো শিখিনি (ArrayList, Stream…); থাকলে বাদ দিয়েছি বা পরের জন্য লিখে রেখেছি
• প্রতিটি বদলের পর session.txt দিয়ে পুরো সেশন আবার চালিয়ে আগের আউটপুটের সাথে মিলিয়েছি
• নতুন কমান্ড যোগ করতে main loop বদলাতে হয়নি — নকশা এখনো open/closed
• শেষে প্রতিটি class-এর কাজ এক বাক্যে নিজের ভাষায় বলতে পারি