সিদ্ধান্ত — if/else আর switch expression

১ · প্রোগ্রাম যখন পথ বেছে নেয়

এখন পর্যন্ত আমাদের প্রোগ্রাম চলেছে সোজা রাস্তায় — ওপরের লাইন থেকে নিচের লাইন, একটার পর একটা। পর্ব ০৯-এ Scanner দিয়ে ইনপুট নিয়েছেন। কিন্তু ইনপুট নিয়ে লাভ কী, যদি প্রোগ্রাম সবার জন্য একই কাজ করে? নম্বর ৮৫ হলে “A+” আর ২০ হলে “F” — এই পার্থক্য করতে প্রোগ্রামকে সিদ্ধান্ত নিতে হয়।

Java-তে সিদ্ধান্ত নেওয়ার দুটি প্রধান হাতিয়ার আছে, আর এই পর্ব দুটিকে ঘিরেই:

২ · if, else if, else — আর এক লাইনেও বন্ধনী

if statement-এর তিনটি রূপ আছে। প্রথমটি সবচেয়ে সরল — শর্ত সত্য হলে কিছু করো, নইলে কিছুই না:

if (balance < 100) {
    System.out.println("সতর্কতা: ব্যালেন্স কম");
}

দুই পথের একটি বেছে নিতে else, আর অনেক পথের জন্য else if দিয়ে সারি বানানো হয়:

if (temp >= 35) {
    System.out.println("প্রচণ্ড গরম — পানি খান");
} else if (temp >= 25) {
    System.out.println("আরামদায়ক");
} else {
    System.out.println("শীত পড়েছে — চাদর নিন");
}

খেয়াল করুন, else if আলাদা কোনো keyword নয়। এটি আসলে একটি else, যার ভেতরে আরেকটি if বসানো — শুধু সাজিয়ে লেখা হয় বলে একটি সারির মতো দেখায়। তাই সারির শেষ else বাধ্যতামূলক নয়; তবে “বাকি সব ক্ষেত্রে” কী হবে তা লিখে রাখা প্রায় সবসময় ভালো।

বন্ধনী ছাড়া if — একটি বিপজ্জনক সুবিধা

Java (C-র মতোই) এক লাইনের if-এ বন্ধনী ছাড়তে দেয়: if (x > 3) System.out.println("big");. নিয়মটি হলো — বন্ধনী না থাকলে if-এর অধীনে থাকে শুধু পরের একটি statement. সমস্যা শুরু হয় যখন কেউ পরে আরেকটি লাইন যোগ করেন, আর indentation দেখে ভাবেন সেটিও if-এর ভেতরে:

int x = 5;
if (x > 3)
    System.out.println("big");
    System.out.println("always");   // দেখতে if-এর ভেতরে, আসলে বাইরে

Compiler-এর কাছে indentation-এর কোনো মূল্য নেই (পর্ব ০৪)। "always" লাইনটি সবসময় চলে — x যা-ই হোক। এখানে x = 5 বলে আউটপুটে দুটোই আসে, তাই বাগটি টেস্টেও লুকিয়ে থাকে; x = 1 দিলে ধরা পড়ত।

মজার ব্যাপার, ঠিক ওই ধরনের ভুল Java-তে কখনো কখনো compile-এর সময়ই ধরা পড়ে। বন্ধনী ছাড়া if-এর পরে একটি return “বাইরে” চলে গেলে তার পরের লাইনে কখনো পৌঁছানো যায় না, আর Java এমন unreachable statement-কে error বলে (অনলাইন runner-এ যাচাই করা):

prog.java:6: error: unreachable statement
        return "সফল";
        ^
1 error

কিন্তু এটি ভাগ্যের ব্যাপার, নিয়ম নয় — ওপরের "always" উদাহরণে কোনো error আসেনি। নিরাপদ পথ একটাই: সবসময় বন্ধনী। IntelliJ IDEA আর বেশিরভাগ code formatter চাইলে নিজেই বন্ধনী বসিয়ে দেয়।

৩ · শর্ত মানেই boolean — Java-র কড়া নিয়ম

C-তে যেকোনো সংখ্যা শর্ত হতে পারে: ০ মানে মিথ্যা, বাকি সব সত্য। Python-এ আরও ঢিলা — খালি লিস্ট, খালি String, None সবই “মিথ্যার মতো” (একে বলে truthiness). Java এসব মানে না। if-এর বন্ধনীর ভেতরে থাকতে হবে একটি boolean (বা তার wrapper Boolean) — অন্য কিছু নয়।

এই নিয়মের সবচেয়ে বড় লাভ একটি বিখ্যাত টাইপো ধরা: তুলনার ==-এর বদলে ভুল করে একটি = লেখা। C-তে if (x = 5) বৈধ — x-এ 5 বসে, আর 5 শূন্য নয় বলে শর্ত সবসময় সত্য। Java-তে একই লাইন লিখলে (অনলাইন runner, OpenJDK 21):

prog.java:4: error: incompatible types: int cannot be converted to boolean
        if (x = 5) {
              ^
1 error

মেসেজটি পড়ুন: x = 5 একটি assignment, যার ফল int মান 5. আর int থেকে boolean-এ যাওয়ার কোনো পথ Java রাখেনি। একই কারণে if (count) বা if (name) লেখা যায় না — স্পষ্ট করে লিখতে হয় if (count != 0) বা if (name != null).

শর্ত লেখার কয়েকটি ভালো অভ্যাস

পর্ব ০৭-এ দেখেছেন, && আর || short-circuit করে — বাঁ দিক দেখেই উত্তর জানা গেলে ডান দিক আর যাচাই করে না। সিদ্ধান্তের কোডে এটি নিরাপত্তার কাজ করে: if (name != null && name.isEmpty()) — name null হলে ডান দিকে যাওয়াই হয় না, তাই কোনো null-এর বিপদ নেই। ক্রম উল্টে দিলে সেই সুরক্ষা হারায়।

• জটিল শর্তে নাম দিন: boolean isWeekend = day == 6 || day == 7; তারপর if (isWeekend) — কোড নিজেই নিজের ব্যাখ্যা।
• String তুলনায় == নয়, equals: পর্ব ০৮-এ দেখেছেন, == দেখে দুটি reference একই object কি না। if (cmd.equals("add")) লিখুন। "add".equals(cmd) লিখলে cmd null হলেও exception আসে না।
• দশমিক সংখ্যা == দিয়ে নয়: 0.1 + 0.2 == 0.3 মিথ্যা — পর্ব ০৬-এর কথা মনে রাখুন। ছোট একটি সীমার ভেতরে আছে কি না দেখুন।

৪ · else-if সারির ক্রম — প্রথম সত্যটিই জেতে

else-if সারি একটি সরল নিয়মে চলে: ওপর থেকে একটি একটি করে শর্ত দেখা হয়; যে শর্ত প্রথম true, শুধু তার block চলে, তারপর পুরো সারি শেষ। নিচের শর্তগুলো আর দেখাই হয় না। নিয়মটি সরল, কিন্তু এর একটি লুকানো ফল আছে: শর্তগুলো যদি একে অপরের ওপর পড়ে (একটি মান একাধিক শর্তে সত্য হয়), তাহলে ক্রমই উত্তর ঠিক করে।

উদাহরণ হিসেবে নেওয়া যাক বাংলাদেশের মাধ্যমিক ও উচ্চমাধ্যমিক পরীক্ষায় প্রচলিত ৫-পয়েন্ট গ্রেড স্কেল: ৮০ বা বেশি A+ (৫.০০), ৭০–৭৯ A (৪.০০), ৬০–৬৯ A- (৩.৫০), ৫০–৫৯ B, ৪০–৪৯ C, ৩৩–৩৯ D, আর ৩৩-এর নিচে F. নম্বর ৭৫ হলে কী হয়, দেখুন — আর তারপর দেখুন কেউ শর্তগুলো উল্টো ক্রমে লিখলে কী ঘটে:

if (marks >= 80) {          // 75 >= 80 ? false
    grade = "A+";
} else if (marks >= 70) {
    grade = "A";
} else if (marks >= 60) {
    grade = "A-";
} ...
} else {
    grade = "F";
}

if (marks >= 80) {          // false, বাদ
    grade = "A+";
} else if (marks >= 70) {   // 75 >= 70 ? true
    grade = "A";             // এটিই চলল
} else if (marks >= 60) {   // দেখাই হলো না
    grade = "A-";
} ...                       // দেখাই হলো না

grade = "A"  ✔

if (marks >= 33) {          // 75 >= 33 ? true
    grade = "D";             // এটিই চলল!
} else if (marks >= 40) {   // কখনো দেখা হবে না
    grade = "C";
} else if (marks >= 70) {   // কখনো দেখা হবে না
    grade = "A";
} ...
} else {
    grade = "F";
}

grade = "D"  ✘   (হওয়ার কথা "A")

// সমাধান ১: কড়া শর্ত আগে (বড় সীমা ওপরে)
if (marks >= 80)      { grade = "A+"; }
else if (marks >= 70) { grade = "A"; }
...

// সমাধান ২: প্রতিটি শর্ত পূর্ণ পরিসর বলে —
// তখন ক্রম বদলালেও উত্তর বদলায় না
if (marks >= 70 && marks < 80) { grade = "A"; }

এবার পুরো গ্রেড ক্যালকুলেটর চালিয়ে দেখুন। শর্তের ক্রম সঠিক, প্রতিটি শাখায় বন্ধনী আছে, আর একদম শুরুতে একটি ছোট পাহারাদার শর্ত — যার কথা পরের অংশে বিস্তারিত:

class Main {
    // নম্বর থেকে গ্রেড — ৫-পয়েন্ট স্কেলের একটি উদাহরণ
    static String grade(int marks) {
        if (marks < 0 || marks > 100) {
            return "ভুল নম্বর";              // guard clause
        }
        if (marks >= 80)      { return "A+ (5.00)"; }
        else if (marks >= 70) { return "A (4.00)"; }
        else if (marks >= 60) { return "A- (3.50)"; }
        else if (marks >= 50) { return "B (3.00)"; }
        else if (marks >= 40) { return "C (2.00)"; }
        else if (marks >= 33) { return "D (1.00)"; }
        else                  { return "F (0.00)"; }
    }

    public static void main(String[] args) {
        System.out.println("95 -> " + grade(95));
        System.out.println("75 -> " + grade(75));
        System.out.println("33 -> " + grade(33));
        System.out.println("32 -> " + grade(32));
        System.out.println("105 -> " + grade(105));
    }
}

৫ · Nested if বনাম guard clause, আর ternary

if-এর ভেতরে if বসানো যায় — একে বলে nested if. দু-এক স্তর ঠিক আছে, কিন্তু তিন-চার স্তর হলে কোড ডানদিকে সরতে সরতে একটি তীরের ফলার আকার নেয় (প্রোগ্রামাররা মজা করে বলেন “arrow code”). তখন কোন else কোন if-এর, তা খুঁজতে আঙুল দিয়ে বন্ধনী গুনতে হয়।

ধরা যাক একটি মোবাইল ওয়ালেট থেকে টাকা তোলার নিয়ম: PIN ঠিক হতে হবে, অঙ্ক শূন্যের বেশি হতে হবে, আর ব্যালেন্সে কুলাতে হবে। নিচের ডায়াগ্রামে একই নিয়ম দুইভাবে লেখা — দেখুন guard clause দিয়ে কোড কীভাবে সোজা হয়:

if (pinOk) {
    if (amount > 0) {
        if (amount <= balance) {
            return "সফল";          // আসল কাজ — সবচেয়ে গভীরে
        } else {
            return "ব্যালেন্স কম";
        }
    } else {
        return "ভুল অঙ্ক";
    }
} else {
    return "PIN ভুল";              // শর্ত থেকে অনেক দূরে
}

if (!pinOk) { return "PIN ভুল"; }

if (amount > 0) {
    if (amount <= balance) {
        return "সফল";
    } else {
        return "ব্যালেন্স কম";
    }
} else {
    return "ভুল অঙ্ক";
}

if (!pinOk)      { return "PIN ভুল"; }
if (amount <= 0) { return "ভুল অঙ্ক"; }

if (amount <= balance) {
    return "সফল";
} else {
    return "ব্যালেন্স কম";
}

if (!pinOk)            { return "PIN ভুল"; }
if (amount <= 0)       { return "ভুল অঙ্ক"; }
if (amount > balance)  { return "ব্যালেন্স কম"; }

return "সফল";                     // আসল কাজ — কোনো nesting নেই

Ternary — দুই মানের একটি বাছাই (রিক্যাপ)

পর্ব ০৭-এ দেখা ternary operator হলো if/else-এর একটি ছোট expression রূপ: String result = marks >= 33 ? "পাস" : "ফেল";. পার্থক্যটি গুরুত্বপূর্ণ — if/else একটি statement, যা কাজ করে; ternary একটি expression, যা একটি মান দেয়। তাই ternary সরাসরি ভ্যারিয়েবলে বসানো বা println-এর ভেতরে লেখা যায়। নিয়ম: দুটি সরল মানের মধ্যে বাছাই হলে ternary; শাখার ভেতরে কাজ থাকলে, বা ternary-র ভেতরে আরেকটি ternary লাগলে, if/else বা switch expression ব্যবহার করুন। “statement বনাম expression” — এই পার্থক্যটি মনে রাখুন; পরের অংশে switch-এর আধুনিক রূপ ঠিক এখানেই নতুন।

৬ · পুরোনো switch — case, break আর fall-through

একটি মানকে অনেকগুলো নির্দিষ্ট মানের সাথে মেলাতে হলে else-if সারি লম্বা আর একঘেয়ে হয়ে যায়: if (plan == 1) … else if (plan == 2) … else if (plan == 3) …. এর জন্য Java শুরু থেকেই C-র কাছ থেকে নিয়েছে switch statement. বন্ধনীর ভেতরের মানটিকে বলে selector, আর প্রতিটি সম্ভাব্য মান একটি case label:

switch (plan) {
    case 1:
        System.out.println("Basic");
        break;
    case 2:
        System.out.println("Standard");
        break;
    default:
        System.out.println("Unknown");
}

একটি জরুরি কথা বুঝে নিন: পুরোনো switch-এ case 1: কোনো আলাদা block নয় — এটি শুধু একটি লাফ দেওয়ার জায়গা, অনেকটা বইয়ের পৃষ্ঠা-চিহ্নের মতো। switch মিলে যাওয়া লেবেলে লাফ দেয়, তারপর সেখান থেকে নিচের দিকে সব লাইন চালাতে থাকে — যতক্ষণ না একটি break পায় বা switch শেষ হয়। অন্য case-এর লেবেল পেরিয়ে যাওয়ার সময় সেটিকে আর যাচাই করে না। একে বলে fall-through. break ভুলে গেলে কী হয়, ধাপে ধাপে দেখুন:

1int plan = 1;2switch (plan) {3    case 1:4        System.out.println("Basic");5    case 2:              // break নেই উপরে!6        System.out.println("Standard");7        break;8    case 3:9        System.out.println("Premium");10        break;11    default:12        System.out.println("Unknown");13}

switch (plan) {
    case 1 -> System.out.println("Basic");
    case 2 -> System.out.println("Standard");
    case 3 -> System.out.println("Premium");
    default -> System.out.println("Unknown");
}

আউটপুট (plan = 1):
Basic

Fall-through কি সবসময় বাগ?

না — কখনো এটি ইচ্ছাকৃত। কয়েকটি মানের জন্য একই কাজ হলে লেবেলগুলো একটার নিচে আরেকটা খালি রাখা হয়: case 6: case 7: তারপর System.out.println("ছুটি"); break;. খালি লেবেল থেকে গড়িয়ে পড়া নিরীহ। বিপদ হয় যখন একটি case-এ কাজ আছে, আর break নেই। পেশাদার কোডে ইচ্ছাকৃত fall-through থাকলে পাশে // fall through comment লেখার প্রথা আছে, যাতে পাঠক বোঝেন এটি ভুল নয়। আধুনিক রূপে একই কাজ আরও পরিষ্কার: case 6, 7 -> ….

switch কোন কোন টাইপে চলে

String-এর switch সম্পর্কে একটি সূক্ষ্ম কথা: পর্ব ০৮-এ দেখেছেন, দুটি String-এর লেখা এক হলেও == মিথ্যা হতে পারে, কারণ তারা আলাদা object. switch এই ফাঁদে পড়ে না — ভেতরে সে আগে লেখার hashCode() দিয়ে সম্ভাব্য case খুঁজে নেয়, তারপর equals দিয়ে নিশ্চিত হয়। যাচাই করে দেখা গেছে: "ad" + "d" থেকে বানানো String-এর ক্ষেত্রে t == "add" false, কিন্তু case "add" ঠিকই মিলেছে। তবে তুলনাটি হুবহু — "Add" বা " add" মিলবে না। তাই ব্যবহারকারীর ইনপুটে switch করার আগে সাধারণত trim() আর toLowerCase() করে নেওয়া হয় (অংশ ৭-এর কমান্ড পার্সারে দেখবেন)।

৭ · আধুনিক switch — মান ফেরত দেয়, গড়ায় না, সব মান যাচাই করে

পুরোনো switch-এর তিনটি দুর্বলতা ছিল: break ভুললে fall-through, কোনো মান ফেরত দিতে পারে না (তাই আগে একটি ভ্যারিয়েবল বানিয়ে প্রতিটি case-এ বসাতে হতো), আর কোনো case বাদ পড়লে কেউ জানায় না। Java 14-এ স্থায়ী হওয়া switch expression (JEP 361) তিনটিরই সমাধান দেয়। পার্থক্যটি পাশাপাশি দেখুন:

int fare;                     // আগে খালি ভ্যারিয়েবল
switch (type) {
    case "adult":
        fare = 60;
        break;
    case "student":
    case "child":
        fare = 30;
        break;
    default:
        fare = 0;             // ভুলে গেলে? fare অনির্ধারিত
}

int fare = switch (type) {    // switch নিজেই একটি মান
    case "adult" -> 60;
    case "student", "child" -> 30;
    default -> 0;
};                            // শেষে সেমিকোলন — এটি একটি statement-এর অংশ

নতুন রূপের চারটি বৈশিষ্ট্য:

• Arrow label (->): ডান দিকে একটি expression, একটি { } block, বা একটি throw. কাজ শেষ হলেই switch শেষ — fall-through নেই।
• এক লেবেলে কয়েকটি মান: case "student", "child" -> — কমা দিয়ে। খালি লেবেলের সারি আর লাগে না।
• মান ফেরত দেয়: পুরো switch একটি expression, তাই int fare = switch (…) {…}; লেখা যায়, বা সরাসরি return switch (…) {…};.
• Exhaustiveness: switch expression-কে সব সম্ভাব্য মানের জন্য একটি মান দিতেই হবে। int বা String-এ সম্ভাব্য মান অসীম, তাই default বাধ্যতামূলক। enum-এ সব নাম লিখে দিলে default লাগে না — compiler নিজেই গুনে দেখে।

yield — block থেকে মান ফেরত

arrow-এর ডান দিকে এক লাইনের বেশি কাজ লাগলে { } block লেখা হয়। কিন্তু block থেকে মান ফেরত দেবেন কীভাবে? return লিখলে তো পুরো method থেকে বেরিয়ে যাওয়ার কথা। তাই Java একটি নতুন শব্দ এনেছে: yield — “এই মানটিই পুরো switch-এর মান”। একটি বাসের ভাড়ার নিয়ম দিয়ে দেখুন (নিয়মটি উদাহরণের জন্য বানানো): প্রাপ্তবয়স্ক পুরো ভাড়া, ছাত্রছাত্রী অর্ধেক, শিশু আর প্রবীণ ৭০% ছাড়ে — তবে অন্তত ১০ টাকা।

1static int fare(Passenger p, int base) {2    return switch (p) {3        case ADULT -> base;4        case STUDENT -> base / 2;5        case CHILD, SENIOR -> {6            int discounted = base * 30 / 100;7            yield Math.max(discounted, 10);8        }9    };10}

এবার পুরোটা চালিয়ে দেখুন — চার ধরনের যাত্রী:

enum Passenger { ADULT, STUDENT, CHILD, SENIOR }

class Main {
    static int fare(Passenger p, int base) {
        return switch (p) {
            case ADULT -> base;
            case STUDENT -> base / 2;                 // অর্ধেক ভাড়া
            case CHILD, SENIOR -> {
                int discounted = base * 30 / 100;    // ৭০% ছাড়
                yield Math.max(discounted, 10);      // তবে অন্তত ১০ টাকা
            }
        };                                            // default নেই: চারটি মানই আছে
    }

    public static void main(String[] args) {
        System.out.println("Adult: " + fare(Passenger.ADULT, 60));
        System.out.println("Student: " + fare(Passenger.STUDENT, 60));
        System.out.println("Senior: " + fare(Passenger.SENIOR, 60));
        System.out.println("Child (short trip): " + fare(Passenger.CHILD, 20));
    }
}

কোনো মান বাদ পড়লে javac যা বলে (অনলাইন runner-এ যাচাই করা, ওপরের কোডে case CHILD, SENIOR থেকে SENIOR বাদ দিয়ে):

prog.java:5: error: the switch expression does not cover all possible input values
        return switch (p) {
               ^
1 error

একই মেসেজ আসে int বা String-এর switch expression-এ default না দিলে। লক্ষ করুন: এই যাচাই শুধু switch expression-এর (আর pattern ব্যবহার করা switch-এর) জন্য। পুরোনো ধরনের switch statement-এ enum-এর একটি case বাদ পড়লে কোনো error আসে না — সেই case-এ কিছুই চলে না, চুপচাপ।

বাস্তব উদাহরণ: দিনের বাংলা নাম

Java-র নিজের java.time.DayOfWeek একটি enum (MONDAY থেকে SUNDAY). সাতটি case লিখে দিলে default লাগে না:

static String banglaDay(DayOfWeek d) {
    return switch (d) {
        case SATURDAY  -> "শনিবার";
        case SUNDAY    -> "রবিবার";
        case MONDAY    -> "সোমবার";
        case TUESDAY   -> "মঙ্গলবার";
        case WEDNESDAY -> "বুধবার";
        case THURSDAY  -> "বৃহস্পতিবার";
        case FRIDAY    -> "শুক্রবার";
    };
}
// banglaDay(DayOfWeek.FRIDAY) → শুক্রবার, banglaDay(DayOfWeek.of(1)) → সোমবার

অনলাইন runner-এ চালিয়ে মন্তব্যের আউটপুট দুটিই মিলেছে (DayOfWeek.of(1) হলো সোমবার, কারণ ISO নিয়মে সপ্তাহ শুরু সোমবার থেকে)। একটি case মুছলে compile error — দিন ভুলে যাওয়ার কোনো উপায় নেই।

বাস্তব উদাহরণ: ছোট্ট কমান্ড পার্সার

একটি todo অ্যাপ ব্যবহারকারীর কাছ থেকে add, list, done কমান্ড নেয়। String-এর switch expression দিয়ে:

static String command(String cmd) {
    return switch (cmd.trim().toLowerCase()) {
        case "add", "a" -> "নতুন কাজ যোগ হলো";
        case "list"     -> "সব কাজের তালিকা";
        case "done"     -> "কাজটি শেষ চিহ্নিত হলো";
        default         -> "অচেনা কমান্ড: " + cmd.trim();
    };
}
// command("  ADD ") → নতুন কাজ যোগ হলো
// command("fly")    → অচেনা কমান্ড: fly

trim() দুই পাশের ফাঁকা জায়গা ফেলে, toLowerCase() সব ছোট হাতে আনে — তাই " ADD "-ও মিলে গেছে (অনলাইন runner-এ যাচাই করা)। default এখানে শুধু compiler-কে খুশি রাখার জন্য নয়, এটি ব্যবহারকারীকে বলে কী ভুল হলো। পর্ব ২২-এর মাঝপথের প্রজেক্টে এমন একটি পার্সারকে আপনি একটি পূর্ণ CLI টুলে বড় করবেন।

৮ · null, pattern matching-এর এক ঝলক, আর নিরাপদ default

switch-এ null এলে

কমান্ডটি যদি কোথাও থেকে null হয়ে আসে? পুরোনো নিয়মে (case null ছাড়া) switch null পেলেই থেমে যায়। অনলাইন runner-এ যাচাই করা আউটপুট:

Exception in thread "main" java.lang.NullPointerException: Cannot invoke "String.hashCode()" because "<local2>" is null
	at Main.main(prog.java:4)

এই stack trace থেকে দুটি জিনিস শেখা যায়। এক, এটি একটি NullPointerException, ঘটেছে switch-এর লাইনে (৪)। দুই, মেসেজে String.hashCode() — অংশ ৬-এ বলা সেই ভেতরের কৌশলটি নিজের চোখে দেখা গেল: String-এর switch আগে hashCode ডাকে, আর null-এর কোনো hashCode নেই। <local2> হলো compiler-এর বানানো একটি লুকানো ভ্যারিয়েবল, যার নাম class ফাইলে রাখা হয়নি।

Java 21 থেকে (JEP 441) switch-এ সরাসরি case null লেখা যায়:

switch (cmd) {
    case null  -> System.out.println("ফাঁকা কমান্ড");
    case "add" -> System.out.println("add");
    default    -> System.out.println("অচেনা");
}
// cmd = null হলে আউটপুট: ফাঁকা কমান্ড

case null না লিখলে আচরণ আগের মতোই থাকে — NullPointerException. অর্থাৎ নতুন সুবিধাটি পুরোনো কোডের আচরণ বদলায়নি, শুধু চাইলে null-কে স্পষ্টভাবে সামলানোর একটি জায়গা দিয়েছে।

Pattern matching — শুধু মান নয়, টাইপও মেলানো (এক ঝলক)

এতক্ষণ case-এ বসেছে নির্দিষ্ট মান: 1, "add", SENIOR. Java 21-এ স্থায়ী হওয়া pattern matching for switch (JEP 441) দিয়ে case-এ একটি টাইপ বসানো যায়, আর মিললে মানটি সেই টাইপের নতুন ভ্যারিয়েবলে চলে আসে। সাথে when দিয়ে একটি অতিরিক্ত শর্ত — একে বলে guard:

static String describe(Object o) {
    return switch (o) {
        case null                   -> "কিছুই নেই (null)";
        case Integer i when i > 100 -> "বড় সংখ্যা: " + i;
        case Integer i              -> "ছোট সংখ্যা: " + i;
        case String s               -> "লেখা, দৈর্ঘ্য " + s.length();
        default                     -> "অন্য কিছু";
    };
}
// describe(250) → বড় সংখ্যা: 250    describe(7) → ছোট সংখ্যা: 7
// describe("Dhaka") → লেখা, দৈর্ঘ্য 5    describe(3.5) → অন্য কিছু

সব আউটপুট অনলাইন runner-এ (Java 21) যাচাই করা। দুটি জিনিস লক্ষ করুন: এখানেও ক্রম গুরুত্বপূর্ণ — when i > 100-ওয়ালা case সাধারণ Integer i-এর আগে, ঠিক else-if সারির “কড়া শর্ত আগে” নিয়মের মতো (উল্টো ক্রমে লিখলে javac নিজেই error দেয়, কারণ পরেরটি কখনো পৌঁছানো যাবে না)। আর Object-এর সম্ভাব্য টাইপ অসীম, তাই default বাধ্যতামূলক। এই সুবিধার আসল শক্তি দেখা যায় record আর sealed টাইপের সাথে, যেখানে compiler সব উপ-টাইপ জানে বলে default ছাড়াই exhaustiveness যাচাই করতে পারে — সেটি পর্ব ২৬-এর বিষয়।

নিরাপদ default — অসম্ভবকেও সামলান

অনেক সময় ভাবি “এই মান তো কখনো আসবে না”। কিন্তু ইনপুট আসে মানুষের কাছ থেকে, ফাইল থেকে, নেটওয়ার্ক থেকে — আর “কখনো না” একদিন আসেই। default নিয়ে তিনটি নিয়ম মনে রাখুন:

• int/String-এর switch-এ default চুপচাপ রাখবেন না। অচেনা মান এলে হয় ব্যবহারকারীকে বলুন (কমান্ড পার্সারের মতো), নয়তো একটি exception ছুড়ুন: default -> throw new IllegalArgumentException("Unknown plan: " + plan); — arrow-এর ডান দিকে throw বৈধ। ভুল জায়গায় থেমে যাওয়া ভালো, ভুল উত্তর নিয়ে এগোনো খারাপ।
• enum-এর switch expression-এ default বাদ দিন। তাহলে নতুন enum মান যোগ হলে compiler আপনাকে প্রতিটি switch দেখিয়ে দেবে। (তবু যদি কোনো পুরোনো compile করা কোড নতুন মান পায়, compiler নিজেই একটি লুকানো default বসায়, যা exception ছোড়ে — ভুল মান নিয়ে চুপচাপ চলে না।)
• “অসম্ভব” শাখাও লিখে রাখুন। else-if সারির শেষ else বা switch-এর default-এ অন্তত একটি স্পষ্ট বার্তা দিন — ছয় মাস পরে বাগ খুঁজতে এটিই প্রথম সূত্র দেবে।

৯ · AI-এর যুগে — AI-এর লেখা সিদ্ধান্ত যাচাই করা

সিদ্ধান্তের কোড AI খুব দ্রুত লেখে, আর দেখতে প্রায় সবসময় ঠিক লাগে। সমস্যা হলো, এই পর্বের প্রায় সব বাগ — ক্রমের ভুল, হারানো break, ভুলে যাওয়া default — compile হয়ে যায়, চলেও। AI-এর প্রশিক্ষণ-ডেটায় কয়েক দশকের পুরোনো Java কোড আছে, তাই সে প্রায়ই পুরোনো ধাঁচে লেখে।

AI সাধারণত যে ভুলগুলো করে

AI-এর লেখা সিদ্ধান্ত-কোড হাতে পেলে — যাচাইয়ের চেকলিস্ট

• প্রতিটি colon-রূপের case-এর শেষে break আছে, অথবা কোডটি arrow রূপে লেখা
• else-if সারিতে শর্তগুলো একে অপরের ওপর পড়লে কড়াটি আগে আছে — একটি মাঝারি মান দিয়ে মাথায় চালিয়ে দেখেছি
• সীমার মানগুলো (যেমন ৩২, ৩৩, ৭৯, ৮০) নিজে চালিয়ে মিলিয়েছি — AI-এর টেবিলে বিশ্বাস করে নয়
• অচেনা বা অবৈধ ইনপুটে কী হয় দেখেছি — default বা শেষ else চুপচাপ কিছু গিলে ফেলছে না
• enum-এর switch expression-এ অপ্রয়োজনীয় default নেই, আর String তুলনায় == নেই
• null আসতে পারে এমন জায়গায় (যেমন switch-এর selector) null-এর ব্যবস্থা আছে