ආයුබෝවන් කට්ටියට! Java Enums ගැන මේ හැමදේම දැනගමු!

කොහොමද ඉතින්, වැඩ එහෙම සාර්ථකද? අද අපි කතා කරන්න යන්නේ Java වල ගොඩක් වැදගත්, හැබැයි සමහරුන්ට අවුල් වෙන, තව සමහරුන්ට එච්චරටම ඕන වෙන්නේ නැති කියලා හිතෙන, ඒත් අනිවාර්යයෙන්ම දැනගෙන ඉන්න ඕන දෙයක් ගැන – ඒ තමයි Java Enums.

Software Development වලදී අපිට නිතරම වගේ ස්ථාවර (constant) අගයන් ගොඩක් එක්ක වැඩ කරන්න වෙනවා නේද? උදාහරණයක් විදියට, සතියේ දවස් (MONDAY, TUESDAY..), මාස (JANUARY, FEBRUARY..), නැත්නම් යම්කිසි පද්ධතියක තත්වයන් (PENDING, APPROVED, REJECTED) වගේ දේවල්.

ඉස්සර මේවට String constants නැත්නම් public static final int constants පාවිච්චි කළා. ඒත් ඒකේ අවුල් ගොඩක් තිබුණා. Type safety නැතිවීම, typo errors, readability අඩු වීම වගේ. Java Enums මේ හැම ප්‍රශ්නෙටම නියම විසඳුමක්. අද අපි මේ Enums කියන්නේ මොනවද, ඒවා කොහොමද හදන්නේ, ඒවාට methods, constructors, fields කොහොමද දාන්නේ, සහ මොන වගේ අවස්ථාවලදීද Enums පාවිච්චි කරන්නේ කියලා හොඳටම පැහැදිලි කරගමු.

Enum එකක් කියන්නේ මොකක්ද? (What are Enums?)

Enum කියන්නේ "Enumeration" කියන එකේ කෙටි යෙදුම. සරලව කිව්වොත්, Enum එකක් කියන්නේ නියත අගයන් (fixed set of constants) සමූහයක් නියෝජනය කරන special class එකක්.

මේවා final class වගේ. ඒ කියන්නේ extend කරන්න බෑ. ඒ වගේම මේවාට constructors, methods, fields වගේම වෙනත් class එකක වගේම දේවල් එකතු කරන්නත් පුළුවන්.

මුලින්ම Enums ආවේ Java 5 එකත් එක්ක. ඒ ආවේ type-safe constants හදන්න. String constants නැත්නම් int constants පාවිච්චි කරනකොට තිබ්බ ලොකුම ප්‍රශ්නයක් තමයි type safety නැති එක. උදාහරණයක් විදියට, int එකක් යන්න ඕන තැනකට වෙන int එකක් ගියොත් compile error එකක් දෙන්නේ නෑ. ඒත් Enum එකකදී එහෙම වෙන්නේ නෑ. Enum එකකින් අපිට බලාපොරොත්තු වෙන අගයන් ටික විතරක් පාවිච්චි කරන්න පුළුවන් වෙනවා.

තව වැදගත් දේ තමයි, Enums කියන්නේ java.lang.Enum class එක extend කරන class වර්ගයක්. ඒ නිසා Enum class එකේ තියෙන name(), ordinal(), valueOf() වගේ Methods අපිට පාවිච්චි කරන්න පුළුවන්.

සරල Enum උදාහරණයක් (Basic Enum Example)

අපි මුලින්ම සරලව Enum එකක් හදලා බලමු. සතියේ දවස් ටික Enum එකකින් කොහොමද නියෝජනය කරන්නේ කියලා බලමු.

public enum Day {
    MONDAY,
    TUESDAY,
    WEDNESDAY,
    THURSDAY,
    FRIDAY,
    SATURDAY,
    SUNDAY
}

මේක තමයි සරලම Enum එකක් හදන විදිය. දැන් මේ Day Enum එක අපේ code එකේ කොහොමද පාවිච්චි කරන්නේ කියලා බලමු.

public class EnumBasicExample {
    public static void main(String[] args) {
        Day today = Day.MONDAY; // Enum constant එකක් declare කරන විදිය
        System.out.println("අද දවස: " + today); // Output: අද දවස: MONDAY

        // Enum constants '==' operator එකෙන් compare කරන්න පුළුවන්
        if (today == Day.MONDAY) {
            System.out.println("අද සඳුදා!");
        }

        // switch statement එකක් එක්ක Enum එකක් පාවිච්චි කිරීම
        switch (today) {
            case MONDAY:
                System.out.println("සඳුදාට වැඩ ගොඩයි.");
                break;
            case SATURDAY:
            case SUNDAY:
                System.out.println("සති අන්තයේ නිවාඩු!");
                break;
            default:
                System.out.println("සාමාන්‍ය දවසක්.");
        }

        // Enum constants ටික Iteration කිරීම
        System.out.println("\nසතියේ දවස්:");
        for (Day day : Day.values()) { // values() method එකෙන් Enum constants array එකක් විදියට ගන්න පුළුවන්
            System.out.println(day);
        }

        // String එකකින් Enum constant එකක් ලබා ගැනීම
        Day weekendDay = Day.valueOf("SATURDAY"); // valueOf() method එකෙන් String එකක් Enum constant එකකට convert කරන්න පුළුවන්
        System.out.println("weekendDay: " + weekendDay);
    }
}

මේකෙන් පේනවා නේද, කොච්චර ලේසියෙන් Enum එකක් පාවිච්චි කරන්න පුළුවන්ද කියලා. switch statements වලදීත් Enum ගොඩක් ප්‍රයෝජනවත් වෙනවා.

Fields සහ Constructors එක්ක Enums (Enums with Fields and Constructors)

Enum constants වලට තවත් data එකතු කරන්න ඕන වුණොත් මොකද කරන්නේ? උදාහරණයක් විදියට, දවසට අදාල short code එකක් (Mon, Tue) වගේ, නැත්නම් ඒ දවස weekday එකක්ද නැත්නම් weekend එකක්ද කියලා Boolean value එකක් වගේ.

මේක කරන්නේ fields (variables) සහ constructors පාවිච්චි කරලා. Enum එකක constructor එක හැමවිටම private විය යුතුයි. මොකද Enum constants ඒවා declare කරනකොටම initialize වෙන නිසා.

public enum Day {
    MONDAY("Mon", true),
    TUESDAY("Tue", true),
    WEDNESDAY("Wed", true),
    THURSDAY("Thu", true),
    FRIDAY("Fri", true),
    SATURDAY("Sat", false),
    SUNDAY("Sun", false);

    // Fields (instance variables) for the enum constants
    private final String shortCode;
    private final boolean isWeekday;

    // Constructor - Must be private or package-private
    private Day(String shortCode, boolean isWeekday) {
        this.shortCode = shortCode;
        this.isWeekday = isWeekday;
    }

    // Public getters to access the fields
    public String getShortCode() {
        return shortCode;
    }

    public boolean isWeekday() {
        return isWeekday;
    }
}

දැන් මේ Day Enum එකට short codes සහ weekday information එකතු කරලා තියෙනවා. මේවා අපේ code එකේ පාවිච්චි කරන හැටි බලමු.

public class EnumFieldsExample {
    public static void main(String[] args) {
        Day today = Day.FRIDAY;

        System.out.println("අද: " + today);
        System.out.println("කෙටි නම: " + today.getShortCode());
        System.out.println("සති අන්ත දවසක්ද?: " + today.isWeekday());

        System.out.println("\nසියලුම දවස් වල විස්තර:");
        for (Day day : Day.values()) {
            System.out.printf("%s (%s) - %s%n", day, day.getShortCode(), day.isWeekday() ? "Weekday" : "Weekend");
        }
    }
}

මේ විදියට Enum එකක හැම constant එකකටම වෙන වෙනම data එකතු කරලා ඒ data එක getters වලින් access කරන්න පුළුවන්. මේකෙන් code එක තවත් readable සහ maintainable වෙනවා.

Methods එක්ක Enums (Enums with Methods)

Enum constants වලට තමන්ටම වෙන් වුණු behavior එකක් (methods) එකතු කරන්නත් පුළුවන්. මේක Java වල "polymorphism" කියන concept එක Enum එකට apply කරන විදිහක්. Enum constant එකකට අදාලව විශේෂ ක්‍රියාවක් කරන්න ඕන වුණොත් මේක ගොඩක් ප්‍රයෝජනවත්.

උදාහරණයක් විදියට, ගණිතමය ක්‍රියාකාරකම් (PLUS, MINUS, MULTIPLY, DIVIDE) නියෝජනය කරන Enum එකක් හදලා, ඒ හැම constant එකකටම අදාල apply method එකක් එකතු කරමු.

public enum Operation {
    PLUS {
        @Override
        public double apply(double x, double y) {
            return x + y;
        }
    },
    MINUS {
        @Override
        public double apply(double x, double y) {
            return x - y;
        }
    },
    MULTIPLY {
        @Override
        public double apply(double x, double y) {
            return x * y;
        }
    },
    DIVIDE {
        @Override
        public double apply(double x, double y) {
            if (y == 0) {
                throw new IllegalArgumentException("Can't divide by zero");
            }
            return x / y;
        }
    };

    // Abstract method that each enum constant must implement
    public abstract double apply(double x, double y);
}

මේ Operation Enum එකේ, හැම constant එකක්ම apply කියන abstract method එක implement කරලා තියෙනවා. ඒක පාවිච්චි කරන හැටි බලමු.

public class EnumMethodsExample {
    public static void main(String[] args) {
        double num1 = 10;
        double num2 = 5;

        // PLUS operation
        Operation plusOp = Operation.PLUS;
        double sum = plusOp.apply(num1, num2);
        System.out.printf("%.1f + %.1f = %.1f%n", num1, num2, sum); // Output: 10.0 + 5.0 = 15.0

        // MULTIPLY operation
        Operation multiplyOp = Operation.MULTIPLY;
        double product = multiplyOp.apply(num1, num2);
        System.out.printf("%.1f * %.1f = %.1f%n", num1, num2, product); // Output: 10.0 * 5.0 = 50.0

        // Iterating through all operations
        System.out.println("\nසියලුම ක්‍රියාකාරකම්:");
        for (Operation op : Operation.values()) {
            try {
                double result = op.apply(10, 2);
                System.out.printf("Operation %s: 10 %s 2 = %.1f%n", op.name(), op.name(), result);
            } catch (IllegalArgumentException e) {
                System.out.printf("Operation %s: Error - %s%n", op.name(), e.getMessage());
            }
        }

        // Example with DIVIDE by zero
        try {
            Operation.DIVIDE.apply(10, 0);
        } catch (IllegalArgumentException e) {
            System.out.println("\nError during division: " + e.getMessage());
        }
    }
}

මේ විදියට Enum එකක තියෙන හැම constant එකකටම තමන්ටම වෙන් වුණු logic එකක් දෙන්න පුළුවන්. මේකෙන් if-else if හෝ switch statements ගොඩවල් නැති කරලා, code එක තවත් clean කරන්න පුළුවන්.

Enum පාවිච්චි කරන්නේ කවදද? (When to Use Enums)

Enum එකක් පාවිච්චි කරන්න හොඳම අවස්ථා කීපයක් මෙන්න:

• ස්ථාවර අගයන් සමූහයක් (Fixed set of constants): සතියේ දවස්, මාස, දිශාවන් (NORTH, SOUTH, EAST, WEST) වගේ.
• තත්ව කේත (Status codes): Order එකක තත්වයන් (PENDING, SHIPPED, DELIVERED, CANCELED) වගේ.
• මෙනු විකල්ප (Menu options): යම්කිසි application එකක options (OPEN, SAVE, EXIT) වගේ.
• සම්බන්ධිත data / behavior සමග අගයන් (Values with related data/behavior): උදාහරණයක් විදියට, currency types (USD, EUR) ඒවාට අදාල symbols සහ conversion rates එක්ක.
• Type-safety වැදගත් වන අවස්ථා (Situations where type-safety is critical): යම්කිසි function එකකට යවන්න පුළුවන් values සීමා කරන්න ඕන වුණාම.

Enums වල වාසි (Benefits of Enums)

Java Enums පාවිච්චි කිරීමෙන් අපිට ගොඩක් වාසි ලැබෙනවා. ඒවායින් කීපයක් මෙන්න:

• Type Safety (Type ආරක්ෂාව):String constants පාවිච්චි කරනකොට typo errors එන්න පුළුවන් ("PENDING" වෙනුවට "PNDING" වගේ). ඒ වගේ වැරදි compile කරනකොට අහු වෙන්නේ නෑ. Runtime එකේදී තමයි bug එකක් විදියට පේන්නේ. ඒත් Enums පාවිච්චි කරනකොට compiler එකම මේ වැරදි අල්ලනවා. ඒක නිසා code එක වඩාත් ශක්තිමත් වෙනවා.
• Readability (කියවීමට පහසු වීම):Code එක වඩාත් පැහැදිලි වෙනවා. අගයන් මොනවාද කියලා Enum name එකෙන් පැහැදිලිව පේනවා. Day.MONDAY කියන එක "MONDAY" කියන String එකට වඩා තේරුම් ගන්න ලේසියි.
• Maintainability (නඩත්තු කිරීමට පහසු වීම):අලුත් constant එකක් එකතු කරනකොට Enum එකට ඒක දාන එක විතරයි කරන්න තියෙන්නේ. ඒ වගේම, Enums වලට Methods එකතු කිරීමෙන් switch statements ගොඩවල් මගහරවා ගන්න පුළුවන්. ඒකෙන් future changes වලදී code එකේ වෙනස්කම් අඩු කරන්න පුළුවන්.
• Cleaner Code (පිරිසිදු code):"Magic numbers" (200, 404 වගේ) නැත්නම් "magic strings" ("ADMIN", "USER" වගේ) පාවිච්චි කරන එක වළක්වනවා. Code එකේ අගයන් වලට තේරුමක් ලැබෙනවා.
• Built-in Methods (බිල්ට්-ඉන් Methods):Enums වලට name() (constant එකේ නම String එකක් විදියට ගන්න), ordinal() (constant එකේ Index එක ගන්න), valueOf() (String එකකින් Enum constant එකක් ගන්න) වගේ Methods ටිකක් default විදියටම ලැබෙනවා. මේවා ගොඩක් ප්‍රයෝජනවත් වෙනවා.

අවසාන වශයෙන් (Conclusion)

ඉතින් යාළුවනේ, මේ Java Enums කියන්නේ පොඩි දෙයක් වගේ පෙනුනත්, අපේ code එක robust, readable, සහ maintainable කරන්න පුළුවන් සුපිරිම feature එකක්. String constants වලින් එන අමාරුකම්, bugs නැති කරගන්න මේ Enums ගොඩක් උදව් වෙනවා. විශේෂයෙන්ම, type-safety කියන එකට Enums දෙන දායකත්වය අති විශාලයි.

ඔයාලට දැන් හොඳ අවබෝධයක් තියෙනවා ඇති Enums ගැන, ඒවාට fields, constructors, methods එකතු කරන්නේ කොහොමද කියලා. අනිවාර්යයෙන්ම මේවා ඔයාලගේ project වලට apply කරලා බලන්න. එතකොට තමා මේකේ නියම වටිනාකම තේරෙන්නේ.

මේ ගැන ඔයාලගේ අදහස්, ප්‍රශ්න පහලින් comment කරන්න. තව මොන වගේ topics ගැනද දැනගන්න කැමති කියලත් කියන්න. තවත් මේ වගේම වැදගත් article එකකින් හම්බවෙමු! සුභ දවසක්!