Java enum — নির্দিষ্ট কয়েকটি মানের নিরাপদ টাইপ

১ · কেন enum — int আর String constant-এর ফাঁদ

একটি অনলাইন শপের অর্ডার ভাবুন। প্রতিটি অর্ডার কোনো এক সময়ে ঠিক একটি অবস্থায় থাকে: অপেক্ষমাণ, টাকা পরিশোধিত, পাঠানো হয়েছে, পৌঁছে গেছে। পঞ্চম কোনো অবস্থা নেই। একই রকম আরও অনেক জিনিস আছে — সপ্তাহের সাত দিন, রক্তের আটটি গ্রুপ, ট্রাফিক সিগন্যালের তিনটি বাতি। এদের সবার একটি মিল: মানটি কয়েকটি আগে থেকে জানা পছন্দের একটি, এর বাইরে কিছু হতে পারে না।

পুরোনো Java কোডে (আর এখনো AI-এর লেখা অনেক কোডে) এমন মান লেখা হতো সংখ্যা দিয়ে — পর্ব ১৮-এর constant ব্যবহার করে:

static final int STATUS_PENDING   = 0;
static final int STATUS_PAID      = 1;
static final int STATUS_SHIPPED   = 2;
static final int STATUS_DELIVERED = 3;

void updateStatus(int status) { ... }

updateStatus(STATUS_PAID);   // ঠিক
updateStatus(42);            // এটাও compile হয়! 42 কোন অবস্থা?
updateStatus(7 * 3 - 20);    // 1 — কাকতালীয়ভাবে PAID

নাম দেওয়ায় কোড পড়া একটু সহজ হয়েছে, কিন্তু টাইপ এখনো int. Compiler-এর চোখে STATUS_PAID আর একটি magic number 42-এর কোনো পার্থক্য নেই — দুটোই int. সমস্যাগুলো একে একে দেখুন:

• যেকোনো সংখ্যা চলে যায়। updateStatus(42) compile হয়; ভুল ধরা পড়ে (যদি পড়ে) চলার সময়, হয়তো গ্রাহকের অভিযোগে।
• আলাদা ধারণা মিশে যায়। BLOOD_A_POS = 1 আর STATUS_PAID = 1 — updateStatus(BLOOD_A_POS) লিখলেও compiler চুপ।
• ছাপালে অর্থহীন। log-এ দেখবেন status=2; 2 মানে কী, খুঁজতে কোডে যেতে হবে।
• সব মান গোনা যায় না। “সব অবস্থার তালিকা দেখাও” — এর জন্য আলাদা array নিজে বানিয়ে রাখতে হয়, আর নতুন অবস্থা যোগ হলে সেটা হালনাগাদ করতে ভুলে যাওয়া সহজ।

অনেকে String দিয়ে সমাধান খোঁজেন: order.setStatus("SHIPPED"). ছাপালে অর্থ বোঝা যায়, কিন্তু নতুন বিপদ: if (status.equals("SHIPED")) — একটি P কম। এটাও নির্ভুলভাবে compile হয়, আর শর্তটি কখনো সত্য হয় না। কেউ লিখবেন "shipped", কেউ "Shipped" — তিনটিই বৈধ String, তিনটিই আলাদা।

Java-র উত্তর enum (enumeration — গুনে গুনে বলা তালিকা)। পর্ব ১০-এ ভাড়ার হিসাবে Passenger enum এক ঝলক দেখেছিলেন; এবার পুরোটা। এই পর্বের মূল ধারণা একটি বাক্যে: enum এমন একটি টাইপ বানায়, যার সম্ভাব্য সব মান আপনি ঘোষণার সময়েই লিখে দেন — আর compiler নিশ্চিত করে এর বাইরে কোনো মান কোথাও আসবে না। একে বলে type safety.

২ · প্রথম enum — ঘোষণা, ব্যবহার আর ==

ঘোষণা এক লাইনের। class-এর জায়গায় enum, আর ভেতরে কমা দিয়ে সব সম্ভাব্য মানের নাম:

enum OrderStatus { PENDING, PAID, SHIPPED, DELIVERED }

class Order {
    private OrderStatus status = OrderStatus.PENDING;    // টাইপ এখন OrderStatus
    void updateStatus(OrderStatus s) { status = s; }
    boolean isDone() { return status == OrderStatus.DELIVERED; }
}

ভেতরের প্রতিটি নামকে বলে enum constant. নিয়ম অনুযায়ী এগুলো সব বড় হাতে, শব্দের মাঝে underscore — UPPER_SNAKE_CASE, ঠিক অন্য constant-এর মতো। এখন সেই পুরোনো ভুলটি আবার করে দেখুন — updateStatus(42):

Main.java:6: error: incompatible types: int cannot be converted to OrderStatus
        updateStatus(42);
                     ^
Note: Some messages have been simplified; recompile with -Xdiags:verbose to get full output
1 error

এটাই পুরো পার্থক্য। OrderStatus টাইপের জায়গায় শুধু চারটি জিনিস বসতে পারে: PENDING, PAID, SHIPPED, DELIVERED (আর reference টাইপ বলে null — সে কথায় পরে আসছি)। কোনো সংখ্যা নয়, কোনো String নয়, অন্য enum-এর মানও নয়। ভুলটি ধরা পড়ল চালানোর আগেই — আপনার কম্পিউটারে, গ্রাহকের ফোনে নয়।

enum আসলে কী — javac-এর ভেতরে এক নজর

C-তে enum মানে নাম দেওয়া int. Java-তে সম্পূর্ণ আলাদা: enum একটি class, আর প্রতিটি constant সেই class-এর একটি object. javac আপনার এক লাইনের ঘোষণা থেকে কী বানায়, ধাপে ধাপে দেখুন (OpenJDK 21-এ reflection দিয়ে যাচাই করা):

enum OrderStatus { PENDING, PAID, SHIPPED, DELIVERED }

এক লাইন। কোনো class, field, constructor চোখে পড়ে না।

final class OrderStatus extends java.lang.Enum<OrderStatus> {
    public static final OrderStatus PENDING;
    public static final OrderStatus PAID;
    public static final OrderStatus SHIPPED;
    public static final OrderStatus DELIVERED;
    private static final OrderStatus[] $VALUES;
    ...
}
প্রতিটি নাম = একটি public static final field

static {                          // compiler-এর লেখা
    PENDING   = new OrderStatus("PENDING",   0);
    PAID      = new OrderStatus("PAID",      1);
    SHIPPED   = new OrderStatus("SHIPPED",   2);
    DELIVERED = new OrderStatus("DELIVERED", 3);
    $VALUES   = $values();        // চারটির array
}
heap-এ ঠিক ৪টি object — এর বেশি কখনো নয়

public static OrderStatus[] values()          // $VALUES-এর কপি
public static OrderStatus valueOf(String name)
private OrderStatus(String name, int ordinal)

new OrderStatus()  →  error: enum classes may not be instantiated
বাইরের কেউ নতুন object বানাতে পারে না

Order a: status ──┐
Order b: status ──┼──►  [ PAID  | name="PAID", ordinal=1 ]
Order c: status ──┘

a.status == b.status   →  true
হাজার অর্ডার, কিন্তু PAID object একটিই

== না equals?

দুটোই কাজ করে, কারণ Enum-এর equals ভেতরে ==-ই করে। তবু == ভালো, দুটি কারণে। এক, status == OrderStatus.PAID-এ status null হলে শুধু false আসে; status.equals(OrderStatus.PAID)-এ আসে NullPointerException. দুই, ==-এ compiler টাইপ মিলিয়ে দেখে — status == BloodGroup.A_POS লিখলে compile error (incomparable types: OrderStatus and BloodGroup), অথচ equals যেকোনো Object নেয়, তাই চুপচাপ false দেয়।

৩ · enum আর switch — সব মান ঢাকা হলো কি না compiler দেখে

পর্ব ১০-এ switch expression শিখেছেন। enum-এর সাথে এটি সবচেয়ে শক্তিশালী জুটি। ঢাকার একটি মোড়ের ট্রাফিক সিগন্যাল ভাবুন:

enum Signal { RED, YELLOW, GREEN }

static int seconds(Signal s) {
    return switch (s) {
        case RED    -> 60;
        case YELLOW -> 5;
        case GREEN  -> 45;
    };                        // default নেই — দরকারও নেই
}

দুটি জিনিস খেয়াল করুন। এক, case-এ শুধু নাম — case RED, Signal.RED লিখতে হয় না, কারণ switch জানে s কোন টাইপের। দুই, কোনো default নেই। int-এর switch expression-এ default বাধ্যতামূলক, কারণ সম্ভাব্য int অসংখ্য। কিন্তু Signal-এর সম্ভাব্য মান মাত্র তিনটি, আর তিনটিরই case আছে — compiler নিজে গুনে নিশ্চিত হয়। একে বলে exhaustiveness. এখন কেউ YELLOW-এর লাইনটি ভুলে মুছে দিলে:

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

আরও গুরুত্বপূর্ণ ঘটনা ঘটে ভবিষ্যতে। ধরুন ছয় মাস পরে কেউ enum-এ FLASHING_YELLOW যোগ করলেন। পুরো প্রজেক্টে যতগুলো switch expression Signal-এর ওপর চলে, প্রতিটি সাথে সাথে compile error দেবে — আর ঠিক সেই জায়গাগুলোই দেখিয়ে দেবে, যেখানে নতুন মানের নিয়ম লিখতে হবে। এজন্য enum-এর switch expression-এ ইচ্ছা করে default রাখবেন না: default থাকলে নতুন মানটি চুপচাপ default-এ চলে যেত।

৪ · প্রতিটি enum-এর সাথে পাওয়া method — values, valueOf, name, ordinal

enum লিখলেই কয়েকটি method বিনা খরচে পাওয়া যায় — কিছু আসে java.lang.Enum থেকে, কিছু compiler যোগ করে:

এবার সব একসাথে চালিয়ে দেখুন — বাংলায় সপ্তাহের দিন দিয়ে। এখানে enum-এ একটি field আর constructor-ও আছে; সেটার বিস্তারিত অংশ ৫-এ, আপাতত শুধু চোখ বুলিয়ে নিন:

enum Day {
    SATURDAY("শনিবার"), SUNDAY("রবিবার"), MONDAY("সোমবার"), TUESDAY("মঙ্গলবার"),
    WEDNESDAY("বুধবার"), THURSDAY("বৃহস্পতিবার"), FRIDAY("শুক্রবার");

    private final String bn;                    // প্রতিটি দিনের নিজের field
    Day(String bn) { this.bn = bn; }            // constructor — নিজে থেকেই private
    String bn() { return bn; }
    boolean isWeekend() { return this == FRIDAY || this == SATURDAY; }
}

class Main {
    public static void main(String[] args) {
        for (Day d : Day.values())
            System.out.println(d.ordinal() + " " + d.name() + " " + d.bn()
                               + (d.isWeekend() ? " (ছুটি)" : ""));
        Day f = Day.valueOf("FRIDAY");          // লেখা থেকে enum
        System.out.println(f == Day.FRIDAY);
        System.out.println(Day.SUNDAY.compareTo(Day.FRIDAY));
        try { Day.valueOf("Friday"); }          // বানান হুবহু না মিললে?
        catch (IllegalArgumentException e) { System.out.println(e.getMessage()); }
    }
}

valueOf — বাইরের লেখা থেকে enum, আর তার exception

valueOf দরকার হয় যখন মান আসে বাইরে থেকে — ফর্মের ইনপুট, ফাইল, JSON, ডেটাবেস। নাম না মিললে সে IllegalArgumentException ছোড়ে। ধরা না হলে প্রোগ্রাম থেমে যায় এই trace দিয়ে (OpenJDK 21):

Exception in thread "main" java.lang.IllegalArgumentException: No enum constant OrderStatus.CANCELLED
	at java.base/java.lang.Enum.valueOf(Enum.java:293)
	at OrderStatus.valueOf(prog.java:1)
	at Main.main(prog.java:5)

নিচ থেকে পড়ুন: main ডেকেছে OrderStatus.valueOf (compiler-এর বানানো method, তাই লাইন নম্বর enum-এর ঘোষণার লাইন), সে ডেকেছে Enum.valueOf, যে নামটি খুঁজে পায়নি। মেসেজটি পরিষ্কার: “OrderStatus-এ CANCELLED নামে কোনো constant নেই।” আর null পাঠালে আসে NullPointerException: Name is null. তাই বাইরের ইনপুট enum-এ বদলানোর সময় সবসময় ভাবুন — ভুল লেখা এলে কী করব? exception ধরে ব্যবহারকারীকে পরিষ্কার বার্তা দেবেন, নাকি একটি নিজস্ব from(String) method লিখবেন যা Optional ফেরত দেয় (পর্ব ৩৬)?

ordinal — আছে, কিন্তু সংরক্ষণ করবেন না

ordinal দেখতে খুব সুবিধাজনক: একটি ছোট সংখ্যা, ডেটাবেসে রাখতে কম জায়গা। কিন্তু ordinal হলো ঘোষণায় অবস্থান — আপনার সোর্স কোডের একটি বিবরণ, ব্যবসার কোনো সত্য নয়। কেউ constant-গুলোর ক্রম বদলালে বা মাঝখানে একটি নতুন constant ঢোকালে সব ordinal সরে যায়। ডেটাবেসে আগে থেকে রাখা সংখ্যাগুলো তখন অন্য অর্থ পায় — কোনো error ছাড়াই:

enum OrderStatus { PENDING, PAID, SHIPPED, DELIVERED }
                     0       1     2        3

orders টেবিল          status (int)
  #101  রহিমের ফোন      1   → PAID
  #102  করিমের বই       2   → SHIPPED
  #103  নীলার শাড়ি      3   → DELIVERED

enum OrderStatus {
    PENDING, PAID, PROCESSING, SHIPPED, DELIVERED
       0      1        2          3        4
}
যৌক্তিক জায়গায় ঢোকানো হলো — PAID-এর পরে, SHIPPED-এর আগে।
compile হয়, সব test-ও পাস করে।

orders টেবিল          status   নতুন কোড পড়ে
  #101  রহিমের ফোন      1   → PAID          ✔
  #102  করিমের বই       2   → PROCESSING    ✘ আসলে পাঠানো হয়ে গেছে
  #103  নীলার শাড়ি      3   → SHIPPED       ✘ আসলে পৌঁছে গেছে
কোনো exception নেই। নীলা আবার “পথে আছে” মেসেজ পেলেন।

orders টেবিল          status (text)
  #101  রহিমের ফোন     "PAID"       → valueOf → PAID       ✔
  #102  করিমের বই      "SHIPPED"    → valueOf → SHIPPED    ✔
  #103  নীলার শাড়ি     "DELIVERED"  → valueOf → DELIVERED  ✔
ক্রম বদলালে বা নতুন constant এলে কিছু যায় আসে না।
সাবধান: constant-এর নাম বদলানো এখন ডেটা-বদলের সমান।

৫ · field, constructor আর method — enum একটি পূর্ণ class

enum যেহেতু class, এতে field, constructor আর method রাখা যায় — ঠিক পর্ব ১৫-১৬-এর মতো। Day-এর উদাহরণে প্রতিটি দিনের সাথে একটি বাংলা নাম জুড়ে দেওয়া হয়েছিল। নিয়মগুলো:

• Constant-গুলো সবার আগে লিখতে হয়; প্রতিটির পরে বন্ধনীতে constructor-এর argument — SATURDAY("শনিবার").
• শেষ constant-এর পরে সেমিকোলন, তারপর field, constructor, method.
• Constructor নিজে থেকেই private. public লিখলে javac বলে modifier public not allowed here. বাইরের কেউ ডাকতে পারে না — constant তৈরির সময় শুধু JVM ডাকে।
• Field সাধারণত private final — প্রতিটি constant সব thread-এ ভাগ হয়, তাই enum immutable রাখাই নিরাপদ।

উদাহরণ: মোবাইল নম্বরের prefix থেকে অপারেটর

বাংলাদেশের মোবাইল নম্বরের প্রথম তিন অঙ্ক দেখে অপারেটর বোঝার চেষ্টা অনেক অ্যাপ করে। নিচের টেবিল শুধু উদাহরণের জন্য একটি সরল তালিকা — বাস্তবে নম্বর এক অপারেটর থেকে আরেকটিতে পোর্ট করা যায়, তাই prefix দেখে অপারেটর নিশ্চিত বলা যায় না:

enum MobileOperator {
    GRAMEENPHONE("গ্রামীণফোন", "017", "013"),
    ROBI("রবি", "018"),
    AIRTEL("এয়ারটেল", "016"),
    BANGLALINK("বাংলালিংক", "019", "014"),
    TELETALK("টেলিটক", "015");                 // ← সেমিকোলন

    private final String bn;
    private final List<String> prefixes;
    MobileOperator(String bn, String... prefixes) {   // varargs, পর্ব ১২
        this.bn = bn;
        this.prefixes = List.of(prefixes);
    }
    String bn() { return bn; }

    static Optional<MobileOperator> fromNumber(String number) {  // "01712345678"
        String p = number.substring(0, 3);
        for (MobileOperator op : values())
            if (op.prefixes.contains(p)) return Optional.of(op);
        return Optional.empty();
    }
}

MobileOperator.fromNumber("01912345678") দেয় Optional[BANGLALINK], আর "01112345678" দেয় Optional.empty. লক্ষ করুন, তথ্য (prefix) আর আচরণ (খোঁজা) দুটোই enum-এর ভেতরে — অন্য কোথাও if (p.equals("017") || p.equals("013")) ছড়িয়ে থাকে না। নতুন prefix যোগ হলে বদলাতে হবে এক জায়গায়।

উদাহরণ: কে কাকে রক্ত দিতে পারে

লোহিত কণিকার (red cell) রক্তদানের সাধারণ নিয়ম: দাতার রক্তে যে antigen (A, B, Rh) আছে, গ্রহীতার রক্তেও তা থাকতে হবে। এই নিয়ম আটটি গ্রুপের জন্য আলাদা আলাদা if-else-এ না লিখে, প্রতিটি গ্রুপকে তার antigen জানিয়ে দিন:

enum BloodGroup {
    O_NEG(false, false, false),  O_POS(false, false, true),
    A_NEG(true,  false, false),  A_POS(true,  false, true),
    B_NEG(false, true,  false),  B_POS(false, true,  true),
    AB_NEG(true, true,  false),  AB_POS(true, true,  true);

    private final boolean a, b, rh;          // কোন antigen আছে
    BloodGroup(boolean a, boolean b, boolean rh) { this.a = a; this.b = b; this.rh = rh; }

    boolean canDonateTo(BloodGroup r) {      // দাতার প্রতিটি antigen গ্রহীতার আছে কি?
        return (!a || r.a) && (!b || r.b) && (!rh || r.rh);
    }
}

ফল: O_NEG.canDonateTo(AB_POS) → true (O− সবাইকে দিতে পারে), A_POS.canDonateTo(A_NEG) → false, B_POS.canDonateTo(A_POS) → false. আটটি গ্রুপ, চৌষট্টিটি জোড়া — অথচ একটিই লাইনের নিয়ম। (এটা প্রোগ্রামিংয়ের উদাহরণ; বাস্তব রক্তদানে আরও অনেক পরীক্ষা লাগে।)

এখানে একটি নকশার শিক্ষা আছে: প্রশ্নটি বস্তুকে জিজ্ঞেস করুন — donor.canDonateTo(patient). পর্ব ১৭-এর “tell, don't ask” নীতির মতোই, enum-এর তথ্য দিয়ে যে সিদ্ধান্ত হয়, সেটা enum-এর method-এ থাকাই স্বাভাবিক।

৬ · প্রতিটি মানের নিজস্ব আচরণ — constant-specific body, lambda আর interface

কখনো প্রতিটি constant-এর কাজটাই আলাদা — শুধু তথ্য নয়। একটি ক্যালকুলেটরের যোগ, বিয়োগ, গুণ ভাবুন। প্রথম চিন্তা আসে switch:

int apply(Operation op, int a, int b) {
    return switch (op) {
        case PLUS  -> a + b;
        case MINUS -> a - b;
    };
}

এটা চলে, আর exhaustiveness-এর পাহারাও আছে। কিন্তু এমন switch যদি প্রজেক্টের দশ জায়গায় থাকে, “Operation কী করে” তা ছড়িয়ে পড়ে দশ ফাইলে। Java-তে প্রতিটি constant নিজের method-এর শরীর রাখতে পারে — একে বলে constant-specific body:

enum Operation {
    PLUS("+")  { int apply(int a, int b) { return a + b; } },
    MINUS("-") { int apply(int a, int b) { return a - b; } };

    private final String symbol;
    Operation(String symbol) { this.symbol = symbol; }
    String symbol() { return symbol; }

    abstract int apply(int a, int b);     // প্রতিটি constant-কে লিখতেই হবে
}

enum-এ একটি abstract method, আর প্রতিটি constant-এর পরে কোঁকড়া বন্ধনীতে তার নিজের সংস্করণ। নতুন constant TIMES("*") যোগ করে তার apply না লিখলে javac থামায়: Operation is abstract; cannot be instantiated — exhaustiveness-এর মতোই পাহারা। ভেতরে javac প্রতিটি শরীরের জন্য একটি নামহীন subclass বানায় (anonymous class, পর্ব ২৭): OpenJDK 21-এ Operation.PLUS.getClass() ছাপে class Operation$1, আর getDeclaringClass() ছাপে class Operation. তাই এমন enum আর final থাকে না — Java 17 থেকে সেটা sealed, যার অনুমোদিত subclass শুধু ওই নামহীন class-গুলো।

আরও পরিষ্কার বিকল্প: lambda field

প্রতিটি constant-এর শরীর যদি এক লাইনের হয়, Java 8-এর lambda দিয়ে আরও সংক্ষেপে লেখা যায় — আচরণটি constructor-এর argument হিসেবে:

enum Operation {
    PLUS("+",  (a, b) -> a + b),
    MINUS("-", (a, b) -> a - b),
    TIMES("*", (a, b) -> a * b);

    private final String symbol;
    private final IntBinaryOperator op;        // java.util.function
    Operation(String symbol, IntBinaryOperator op) { this.symbol = symbol; this.op = op; }
    int apply(int a, int b) { return op.applyAsInt(a, b); }
}

(a, b) -> a + b হলো দুটি int নিয়ে একটি int ফেরত দেওয়া ছোট একটি ফাংশন; IntBinaryOperator তার টাইপ (একটি functional interface). lambda-র পুরো গল্প পর্ব ৩৪-এ। কখন কোনটা? শরীর ছোট আর একই আকারের হলে lambda; প্রতিটি constant-এর আচরণ কয়েক লাইনের বা একাধিক method আলাদা হলে constant-specific body.

enum-ও interface implement করে

enum অন্য class extends করতে পারে না (সে আগেই java.lang.Enum extends করেছে), কিন্তু যত খুশি interface implement করতে পারে। এর একটি সুন্দর ব্যবহার: enum নিজে বন্ধ, নতুন constant বাইরে থেকে যোগ করা যায় না — কিন্তু interface দিয়ে “খোলা” রাখা যায়:

interface Op { int apply(int a, int b); }

enum BasicOp implements Op {
    PLUS  { public int apply(int a, int b) { return a + b; } },
    MINUS { public int apply(int a, int b) { return a - b; } }
}
enum ExtraOp implements Op {               // অন্য দল, অন্য library
    POWER { public int apply(int a, int b) { return (int) Math.pow(a, b); } }
}

static int calc(Op op, int a, int b) { return op.apply(a, b); }   // দুই enum-ই চলে

calc Op চায়, তাই BasicOp আর ExtraOp দুটোরই মান নেয়। Joshua Bloch-এর Effective Java-তে এর নাম “interface দিয়ে extensible enum-এর অনুকরণ”। দাম একটি: Op-এর ওপর switch-এ exhaustiveness আর পাওয়া যায় না, কারণ কতগুলো implementation আছে compiler জানে না।

৭ · EnumSet, EnumMap আর enum singleton

enum-এর মান দিয়ে Set বা Map বানাতে HashSet/HashMap চলে, কিন্তু Java enum-এর জন্য দুটি বিশেষ collection দিয়েছে, যারা দ্রুত, কম জায়গা নেয়, আর ক্রমও সুন্দর।

EnumSet — একসারি সুইচ

EnumSet ভেতরে আসলে একটি bit vector: প্রতিটি constant-এর জন্য একটি bit, ordinal অনুযায়ী জায়গায়। ৬৪টি বা তার কম constant হলে পুরো set একটি মাত্র long সংখ্যা (JDK-তে এর নাম RegularEnumSet). ফলে contains মানে একটি bit দেখা, union মানে একটি OR — HashSet-এর hash হিসাবের চেয়ে অনেক হালকা। ঘরের সুইচবোর্ড ভাবুন: প্রতিটি পাখা-বাতির নিজের সুইচ, আর বোর্ডের দিকে তাকালেই বোঝা যায় কোনগুলো চালু।

EnumSet<Day> weekend = EnumSet.of(Day.FRIDAY, Day.SATURDAY);
EnumSet<Day> workdays = EnumSet.complementOf(weekend);        // বাকি সব
EnumSet<OrderStatus> open = EnumSet.range(OrderStatus.PENDING, OrderStatus.SHIPPED);
EnumSet<OrderStatus> none = EnumSet.noneOf(OrderStatus.class);

ছাপালে ক্রম সবসময় ঘোষণার ক্রম: EnumSet.of(FRIDAY, SATURDAY) ছাপে [SATURDAY, FRIDAY], কারণ Day-এ SATURDAY আগে ঘোষিত। পুরোনো C-ধাঁচের কোডে “bit flag” (READ = 1, WRITE = 2, EXEC = 4, আর | দিয়ে মেলানো) এর কাজ করত; EnumSet একই গতি দেয়, কিন্তু নিরাপদ টাইপ আর পড়ার মতো আউটপুটসহ।

EnumMap — ordinal দিয়ে সাজানো তাক

EnumMap হলো এমন Map, যার key একটি enum. ভেতরে একটি সাধারণ array, যার index হলো key-এর ordinal — hash হিসাব নেই, collision নেই। দোকানের তাক ভাবুন, প্রতিটি তাকের নম্বর আগে থেকে ঠিক করা।

var count = new EnumMap<OrderStatus, Integer>(OrderStatus.class);
count.put(OrderStatus.SHIPPED, 2);
count.put(OrderStatus.PENDING, 7);
count.put(OrderStatus.DELIVERED, 11);
System.out.println(count);     // {PENDING=7, SHIPPED=2, DELIVERED=11}

যে ক্রমেই put করুন, ছাপা হয় ঘোষণার ক্রমে (OpenJDK 21-এ যাচাই করা) — ড্যাশবোর্ডে অর্ডারের অবস্থাগুলো স্বাভাবিক ক্রমে দেখাতে আলাদা করে সাজাতে হয় না। HashMap এই নিশ্চয়তা দেয় না। Set আর Map-এর বিস্তারিত পর্ব ৩১-এ।

enum singleton — এক constant-এর enum

পর্ব ১৮-এ singleton দেখেছেন — পুরো প্রোগ্রামে একটিই object, private constructor আর getInstance() দিয়ে। enum স্বভাবগতভাবেই “নির্দিষ্ট সংখ্যক object”; সেই সংখ্যা এক হলেই singleton:

enum AppConfig {
    INSTANCE;
    private int timeoutSeconds = 30;
    int timeout() { return timeoutSeconds; }
}

int t = AppConfig.INSTANCE.timeout();

Bloch-এর Effective Java (তৃতীয় সংস্করণ, Item 3) একে বলেছে singleton বানানোর প্রায়ই সবচেয়ে ভালো উপায়। কারণ JVM নিজে নিশ্চয়তা দেয়: object তৈরি হয় একবার, thread-safe ভাবে; serialization-এর পরেও একই object ফেরে; আর reflection দিয়ে জোর করে বানাতে গেলে আসে IllegalArgumentException: Cannot reflectively create enum objects (ভাবনার প্রশ্ন ৩)। তবে পর্ব ১৮-এর সতর্কতা এখানেও খাটে: singleton মানে global state, আর test-এ বদলানো কঠিন। বদলযোগ্য অবস্থা রাখা singleton-এর আগে দুবার ভাবুন।

৮ · enum দিয়ে state machine — অর্ডারের যাত্রা

এবার এই পর্বের সবকিছু একসাথে। একটি অর্ডার যেকোনো অবস্থা থেকে যেকোনো অবস্থায় যেতে পারে না। পৌঁছে যাওয়া অর্ডার আবার “অপেক্ষমাণ” হয় না; টাকা না দিয়ে পাঠানো হয় না। এমন নিয়মবদ্ধ যাত্রাকে বলে state machine: কয়েকটি অবস্থা (state), আর কোন অবস্থা থেকে কোনটিতে যাওয়া বৈধ (transition).

  PENDING ──► PAID ──► SHIPPED ──► DELIVERED
     │          │
     └────┬─────┘
          ▼
      CANCELLED        (DELIVERED আর CANCELLED থেকে আর কোথাও যাওয়া যায় না)

সাধারণ কোডে এই নিয়ম ছড়িয়ে থাকে বহু if-এ: “যদি status SHIPPED হয় আর নতুন DELIVERED হয়, তবে…”. enum-এ নিয়মটি প্রতিটি অবস্থার নিজের কাছে রাখা যায় — “আমার পরে কারা আসতে পারে”:

import java.util.*;
enum OrderStatus {
    PENDING, PAID, SHIPPED, DELIVERED, CANCELLED;
    Set<OrderStatus> next() {                   // এই অবস্থা থেকে কোথায় যাওয়া যায়
        return switch (this) {
            case PENDING -> EnumSet.of(PAID, CANCELLED);
            case PAID -> EnumSet.of(SHIPPED, CANCELLED);
            case SHIPPED -> EnumSet.of(DELIVERED);
            case DELIVERED, CANCELLED -> EnumSet.noneOf(OrderStatus.class);
        };
    }
    boolean canMoveTo(OrderStatus target) { return next().contains(target); }
}
class Main {
    public static void main(String[] args) {
        var status = OrderStatus.PENDING;
        for (String req : "PAID DELIVERED SHIPPED DELIVERED PENDING".split(" ")) {
            var target = OrderStatus.valueOf(req);           // লেখা থেকে enum
            boolean ok = status.canMoveTo(target);
            System.out.println(status + " -> " + target
                + (ok ? " : OK" : " : REJECTED, allowed " + status.next()));
            if (ok) status = target;
        }
    }
}

1var status = PENDING;2for (String req : requests) {3  var target = OrderStatus.valueOf(req);4  boolean ok = status.canMoveTo(target);5  println(status -> target : OK / REJECTED);6  if (ok) status = target;7}

বাস্তব সিস্টেমে এর ওপর আরও স্তর আসে — প্রতিটি transition-এর সময় লেখা, কে বদলাল, ডেটাবেসে একই সাথে দুজন বদলালে কী হবে। কিন্তু মূল কাঠামো এটাই: অবস্থা একটি enum, আর বৈধ পথ enum-এর নিজের জ্ঞান। একই ধাঁচে লেখা যায় ট্রাফিক সিগন্যাল (RED → GREEN → YELLOW → RED), পরীক্ষার আবেদনের অবস্থা, বা bKash-এর মতো লেনদেনের অবস্থা (শুরু, যাচাই, সম্পন্ন, ব্যর্থ)।

৯ · enum কখন নয় — sealed/record, আর JSON ও ডেটাবেসে enum

প্রতিটি মানের সাথে আলাদা ডেটা লাগলে

enum-এর প্রতিটি constant একটিই object, আর তার field সবার জন্য এক। “PAID” সব অর্ডারের জন্য একই PAID. কিন্তু যদি প্রতিটি পেমেন্ট-ফলাফলের সাথে নিজস্ব তথ্য লাগে — সফল হলে transaction ID আর টাকার পরিমাণ, ব্যর্থ হলে কারণ? সেটা enum পারে না, কারণ enum-এর মান আগে থেকে নির্দিষ্ট সংখ্যক, চলার সময় নতুন তৈরি হয় না। এর জন্য আধুনিক Java-র উত্তর sealed interface আর record:

// enum: শুধু “কোন ধরন”, ডেটা নেই
enum PaymentState { SUCCESS, FAILED }

// sealed + record: “কোন ধরন” + সেই ধরনের নিজের ডেটা   (পর্ব ২৫, ২৬)
sealed interface PaymentResult permits Success, Failed {}
record Success(String txId, long amountPaisa) implements PaymentResult {}
record Failed(String reason) implements PaymentResult {}

দুটোরই মান সীমিত সংখ্যক “ধরন”-এর একটি, আর দুটোতেই switch-এর exhaustiveness কাজ করে। পার্থক্য: enum-এ প্রতিটি ধরনের ঠিক একটি object; sealed+record-এ প্রতিটি ধরনের অসংখ্য object, প্রত্যেকে নিজের ডেটাসহ। সহজ নিয়ম: মানগুলো শুধু নাম হলে (আর বড়জোর সবার জন্য একই স্থির তথ্য) — enum; প্রতিটি মানের সাথে আলাদা আলাদা ডেটা লাগলে — sealed interface আর record. পর্ব ২৫-এ record, পর্ব ২৬-এ sealed আর pattern matching.

বাইরের তালিকা যদি বদলায়

enum-এর মান বদলাতে কোড বদলে নতুন করে deploy করতে হয়। তাই যে তালিকা ব্যবহারকারী বা অ্যাডমিন চালানোর সময় বদলায় — দোকানের পণ্যের ক্যাটাগরি, শহরের তালিকা যা নিয়মিত বাড়ে, ডিসকাউন্ট কুপন — সেগুলো enum নয়, ডেটাবেসের টেবিল। enum তাদের জন্য, যাদের তালিকা বদলানো মানে প্রোগ্রামের আচরণ বদলানো: অর্ডারের অবস্থা, পেমেন্টের ধরন, রক্তের গ্রুপ।

JSON আর ডেটাবেসে enum

অংশ ৪-এর শিক্ষাই এখানে নিয়ম: বাইরে লিখুন name, ordinal নয়। সুখবর হলো জনপ্রিয় টুলগুলো সাধারণত সেটাই করে — Jackson-এর মতো JSON library ডিফল্টে enum-কে তার নাম হিসেবে লেখে ("status": "SHIPPED", পর্ব ৩৯)। কিন্তু একটি বিখ্যাত ফাঁদ আছে: JPA/Hibernate-এ enum field-এর @Enumerated-এর ডিফল্ট হলো EnumType.ORDINAL. তাই সেখানে প্রতিবার স্পষ্ট লিখতে হয়:

@Enumerated(EnumType.STRING)      // ordinal নয়, নাম সংরক্ষণ — JPA (পর্ব ৪৯-৫০)
private OrderStatus status;

আর অন্য সিস্টেমের সাথে চুক্তি (API, পুরোনো ডেটাবেস) যদি নির্দিষ্ট কোড চায় — যেমন "P", "S" — তাহলে enum-এ একটি স্থির code field রাখুন আর একটি fromCode(String) static method লিখুন। তখন constant-এর নাম বদলালেও বাইরের চুক্তি ভাঙে না। এই lookup-এর জন্য একটি static Map বানাতে চাইলে সেটা constructor-এ ভরা যায় না — কেন, সেটা ভাবনার প্রশ্ন ৪-এর গল্প।

১০ · AI-এর যুগে — String constant, ordinal আর বিশাল switch ধরুন

AI-কে “একটি অর্ডার ম্যানেজমেন্ট সিস্টেম বানাও” বললে প্রায়ই চলনসই কোড আসে, কিন্তু অবস্থাগুলো থাকে String হিসেবে ("pending", "Pending" দুটোই কোথাও কোথাও), অথবা পুরোনো টিউটোরিয়ালের মতো int constant হিসেবে। enum দিলেও আচরণ থাকে বাইরে — পাঁচ ফাইলে পাঁচটি বিশাল switch. এগুলো চোখে না পড়লে প্রথম নতুন অবস্থা যোগ করার দিনেই সমস্যা।

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

• কোথাও "PAID"-এর মতো String বা STATUS_PAID = 1-এর মতো int দিয়ে অবস্থা তুলনা হচ্ছে না
• ordinal() খুঁজে দেখেছি (Ctrl+F) — সংরক্ষণ, হিসাব বা index-এ ব্যবহার নেই; JPA থাকলে EnumType.STRING
• একটি নতুন constant যোগ করে compile করেছি — compiler সেই সব জায়গা দেখিয়েছে যেখানে নিয়ম লাগবে (অর্থাৎ default লুকিয়ে নেই)
• একই enum-এর ওপর একাধিক জায়গায় একই রকম switch নেই; থাকলে method enum-এর ভেতরে সরানো যায় কি না ভেবেছি
• বাইরের ইনপুট (ফর্ম, JSON) থেকে enum বানানোর জায়গায় ভুল বা ছোট হাতের লেখা দিয়ে পরীক্ষা করেছি
• enum-এর সব field private final; তুলনায় ==

enum Color {
    RED, GREEN, BLUE;
    static int count = 0;
    Color() { count++; }
}

Main.java:4: error: illegal reference to static field from initializer
    Color() { count++; }
              ^

private static final Map<String, MobileOperator> BY_PREFIX = new HashMap<>();
static {
    for (MobileOperator op : values())
        for (String p : op.prefixes) BY_PREFIX.put(p, op);
}
static Optional<MobileOperator> fromPrefix(String p) {
    return Optional.ofNullable(BY_PREFIX.get(p));
}