Enumeration in Java

Java SE 5 တွင် Reference Type အသစ်နှစ်မျိုး ဖြည့်စွက်ခဲ့ပါတယ်။ တစ်မျိုးမှာ class ပုံစံ အသစ်တစ်မျိုးဖြစ်တဲ့ enumeration ဖြစ်ပြီး နောက်တစ်မျိုးကတော့ interface ပုံစံအသစ် တစ်မျိုးဖြစ်တဲ့ annotation ဖြစ်ပါသည်။ Enum ဆိုတာကတော့ Enumeration ကိုအတိုကောက်ခေါ်တာဖြစ်ပါတယ်။ Enum type အမျိူးအစားကိုပြောင်းလဲ၍ မရနိုင်သော const တန်ဖိုးများကိုဖော်ပြရန်ဖြစ်ပါတယ်။ လက်တွေ့မှာတော့ Enumerations များအား Constants များအနေနဲ့ အသုံးပြုတဲ့အပြင် singleton pattern များအား ရေးသားတဲ့အခါမှာလည်း အသုံးပြုကြပါတယ်။

class Main {
  public static interface Level {
        public static final int LOW = 1, MEDIUM = 2, HIGH = 3;
    }
    public static void main(String[] args) {
        int level = Level.HIGH;
        level = 4; // can change to other value
        System.out.println(level);
    }
}

Java မှာ Enumeration မပါလာခင်တုန်းက Constants တွေအသုံးပြုချင်တယ်ဆိုရင် static final variable များကို အသုံးပြုခဲ့ကြရပါတယ်။ အထက်ပါ code example မှာဆိုရင် Level အတွက် LOW, MEDIUM, HIGH ၏ တန်ဖိုးများကို static final variable များအဖြစ် အသုံးပြုခဲ့ပါတယ်။ အဲ့လိုအသုံးပြုတဲ့အခါ level ၏တန်ဖိုးမှာ int ဖြစ်တဲ့အတွက်ကြောင့် သတ်မှတ်ထားတဲ့ constant တန်ဖိုးများအပြင် အခြားသော int တန်ဖိုးများကိုလည်း အစားထိုး အသုံးပြုလို့ရနေပါတယ်။ System.out.println() နဲ့ output ထုတ်ပြတဲ့အခါမှာလည်း level အမျိုးအစားကိုထုတ်ပေးမှာမဟုတ်ဘဲ သတ်မှတ်ထားတဲ့ integer ရဲ့တန်ဖိုးကိုသာ ထုတ်ပေးမှာဖြစ်ပါတယ်။

အထက်ပါ အဆင်မပြေမှုတွေအားလုံးကို Enumeration အသုံးပြု၍ အခုလိုဖြေရှင်းနိုင်ပါလိမ့်မယ်။

class Main {
  public enum Level{
        LOW, MEDIUM, HIGH;
    }
    public static void main(String[] args) {
        Level level = Level.HIGH;
        // print it's name
        System.out.println(level.toString());
    }
}

Enums in if Statements

Enum အမျိူးအစားက constants တွေဖြစ်တဲ့အတွက် Program ထဲမှာရှိတဲ့ variables တွေနဲ့ enum constants တွေနဲ့ တိုက်စစ်ရတဲ့ အခြေအနေမျိုးတွေရှိပါတယ်။ အောက်မှာတော့ Enum ကို if statements တွေထဲမှာ ဘယ်လိုအသုံးပြုလို့ရလဲဆိုတာကို ဖော်ပြထားပါတယ်။

class Main {
  public enum Level{
        LOW, MEDIUM, HIGH;
    }
  public static void main(String[] args) {
    Level level = Level.HIGH;
    if( level == Level.HIGH) {
        System.out.println("Level : High");
    } else if( level == Level.MEDIUM) {
        System.out.println("Level : MEDIUM");
    } else if( level == Level.LOW) {
        System.out.println("Level : LOW");
    }
  }
}

Enum ထဲမှာပါတဲ့ constants တန်ဖိုးတွေများရင်တော့ if statements တွေအစား switch statements ကိုအောက်ပါအတိုင်း အသုံးပြုနိုင်ပါတယ်။

Level level = ...  //assign some Level constant to it

switch (level) {
    case HIGH   : ...; break;
    case MEDIUM : ...; break;
    case LOW    : ...; break;
}

Enum Iterations

Enum ထဲက တန်ဖိုးတွေကို Iterations လုပ်ရမယ့် ကိစ္စမျိုးတွေကြုံလာရင်အောက်ပါအတိုင်း ရေးလို့ရပါတယ်။

class Main {
  public enum Level {
        LOW, MEDIUM, HIGH;
    }

    public static void main(String[] args) {
        for (Level level : Level.values()) {
            System.out.println(level);
        }
    }
}

အထက်ပါ code ထဲမှာပါတဲ့ values() method က Enum type ထဲမှာပါတဲ့ method တစ်ခုဖြစ်ပြီး သူက enum constant တွေပါတဲ့ array တစ်ခုကို return ပြန်ပေးပါတယ်။ အဲ့ array ကိုမှ Enhanced for loop နဲ့ပတ်ပြီး output ထုတ်လိုက်တဲ့အခါ အောက်ပါအတိုင်း ထွက်လာပါလိမ့်မယ်။

HIGH
MEDIUM
LOW

Enum Methods

Enum ထဲမှာ Methods တွေကိုလည်းထည့်သွင်းရေးသားနိုင်ပါတယ်။ Example အနေနဲ့ Enum ထဲမှာ constructor နဲ့ getter method ဘယ်လိုရေးလို့ရလဲဆိုတာကိုပြောပြပါမယ်။

class Main {
  public enum Level {
        HIGH(3),
        MEDIUM(2),
        LOW(1);

        private final int levelCode;

        Level(int levelCode) {
            this.levelCode = levelCode;
        }

        public int getLevelCode() {
            return levelCode;
        }
    }

    public static void main(String[] args) {
        Level level = Level.HIGH;
        System.out.println(level.getLevelCode());
    }
}

ဒီ code ကိုကြည့်မယ်ဆိုရင် main method ထဲမှာ enum level ကို HIGH ပေးထားလိုက်တော့ enum ထဲက constructor က levelCode constant ကို 3 အဖြစ်တန်ဖိုးထည့်ပေးလိုက်ပါတယ်။ နောက် line မှာတော့ getLevelCode() ဆိုတဲ့ getter method နဲ့ level ရဲ့တန်ဖိုးကိုယူပြီး print ထုတ်လိုက်တော့ output မှာ 3 ထွက်လာမှာဖြစ်ပါတယ်။

Enum ထဲတွင် getter/setter methods များသာမက enum constant ၏ field တန်ဖိုးများကို အခြေခံပြီး တခြားသော methods များကိုလည်းဖန်တီးရေးသားနိုင်ပါတယ်။

Enum Abstract Methods

Enum class ထဲမှာ Abstract methods များလည်းရေးသားလို့ရပါတယ်။ တကယ်လို့ ကိုယ်က Enum class ထဲမှာ Abstract method တွေထည့်ရေးထားမယ်ဆိုရင် အဲ့ enum class ထဲမှာပါတဲ့ constant တစ်ခုချင်းစီတိုင်းမှာ abstract method တွေကို override လုပ်ပေးပြီး ရေးသားပေးဖို့တော့လိုပါလိမ့်မယ်။ ဥပမာ အားဖြင့် အောက်က example ကိုတစ်ချက်ကြည့်ပေးပါ။

class Main {
  public enum Level {
        HIGH {
            @Override
            public String asLowerCase() {
                return HIGH.toString().toLowerCase();
            }
        },
        MEDIUM {
            @Override
            public String asLowerCase() {
                return MEDIUM.toString().toLowerCase();
            }
        },
        LOW {
            @Override
            public String asLowerCase() {
                return LOW.toString().toLowerCase();
            }
        };

        public abstract String asLowerCase();
    }

    public static void main(String[] args) {
        Level level = Level.LOW;
        System.out.println(level.asLowerCase());
    }
}

Enum class ရဲ့ အောက်ဆုံးမှာ abstract method ကြေငြာထားတာကိုသတိထားမိကြမယ်ထင်ပါတယ်။ ဒီ example မှာတော့ HIGH, MEDIUM, LOW တစ်ခုချင်းစီအတွက် asLowerCase() ဆိုတဲ့ abstract method ကို override လုပ်ထားတာကိုတွေ့ရမှာဖြစ်ပါတယ်။ အဆိုပါ abstract method မျိူးကိုဘယ်အချိန်မှာအသုံးပြုသင့်လဲဆိုတော့ Enum class ထဲက constant တွေအတွက် မတူညီတဲ့ methods များရေးရန်လိုအပ်လာတဲ့အခါမှာ အသုံးပြုနိုင်ပါတယ်။ ဆိုတော့ Enum နဲ့ပတ်သက်တာကတော့ဒီလောက်ပါပဲ။ Java Enum နဲ့ပတ်သက်တဲ့ exercises တွေကို ဒီ link ထဲမှာဝင်လေ့လာလို့ရပါတယ်။