Exception နှင့် အမှားပြင်ဆင်မှု့များ

Exception ဆိုသည်မှာ

ပရိုဂရမ်များကို ရေးသားရာတွင်၎င်း၊ အလုပ်လုပ်စေရာတွင်၎င်း မမျှော်လင့်သော အမှားများကို ရေးမိလေ့ရှိပါသည်။ တခါတလေ ကွန်ပျူတာကို အသုံးပြုရင်း၊ ဘာဖြစ်မှန်းမသိ ရပ်တန့်သွားခြင်း၊ အပြာရောင် စကရင်ကြီးက ပေါ်လာခြင်း အစရှိသည့် အခါများကို ကြုံရလေ့ရှိပါလိမ့်မည်။ အမှားများကြောင့် ဖြစ်ပါသည်။

ပရိုဂရမ်မာ တစ်ယောက်သည် ရေးပြီးပြီးရောမဟုတ်ပဲ ဖြစ်ပေါ်တတ်သောအမှားများနှင့်၊ အမှားများ ဖြစ်ပေါ်လာပါက မည်သို့ လုပ်ဆောင်သင့်ကြောင်း စဉ်းစား၍ အပလီကေးရှင်းများကို ရေးသားရန် လိုအပ်ပါသည်။ ထိုမှသာ အသုံးပြုရလွယ်ကူသော အပလီကေးရှင်းများကို ရေးသားနိုင်မည် ဖြစ်ပါသည်။

Java ဘာသာရပ်တွင် အမှားများကို သင့်တော်သလို ထိမ်းချုပ်နိုင်ပါသည်။ Java ဒြပ်မဲ့စက် (JVM) သည် အလုပ်လုပ်ရင်း အမှားများဖြစ်ပေါ်ပါက အမှားများကို Throwable ကလပ်စ်၏ ဆင့်ပွားကလပ်စ်၏ Object အနေဖြင့် Throw လုပ်မည် ဖြစ်ပြီး၊ ပရိုဂရမ်မာက ထိုအမှား Object ကို Catch လုပ်ပြီး လိုအပ်သလို လမ်းကျောင်းရေးသားနိုင်ပါသည်။

နမှုနာတစ်ခုကို ရေးသားကြည့်ပါမည်။

Sample1.java

public class Sample1 {
    public static void main(String [] args) {
        String param = args[0];
        System.out.println(param);
    }
}

အထက်ပါ Sample1 ကလပ်စ်၏ main လုပ်ဆောင်ချက်တွင် ပါရာမီတာ အဖြစ် String [] args ကိန်းစဉ်ကို ရယူနေပြီး၊ အတွင်းပိုင်းတွင် args ကိန်းစဉ်၏ ၀ မြောက် စာလုံးအား param ကိန်းရှင်တွင် အစားထိုးပါသည်။ ပြီးပါက System.out.println ဖြင့် ကွန်ဆိုးတွင် param ကိန်းရှင်အား ရေးသား နေစေခြင်းသာ ဖြစ်ပါသည်။

ဖော်ပြပါအတိုင်း Sample1.java အား ကွန်ပိုင်းလုပ်၍ java Sample1 Hello ဟု ရေးကြည့်ပါက၊ ကွန်ဆိုးပေါ်တွင် Hello ဟု ပြန်ရေးပြနိုင်ပါသည်။ သို့ရာတွင် ပါရာမီတာမပါပဲ java Sample1 ဟု ရေးသားပါက ကိန်းစဉ် args တွင် ပါရာမီတာ မပါဝင်ပါသဖြင့် ArrayIndexOutOfBoundsException ကို ဖြစ်ပွားစေပါသည်။

အမှား အမျိုးအစားများ

Java ဘာသာရပ်တွင် အသုံးပြုသော အမှား များ၏အခြေခံ ကလပ်စ်မှာ Throwable ဖြစ်ပြီး၊ အမှားများ၏ သဘောသဘာဝ အပေါ်တွင် မှုတည်၍ ဆင့်ပွားကလပ်စ် များကို ပြင်ဆင်ထားပါသည်။ Java ဒြပ်မဲ့စက်တွင် ပြုပြင်၍ မရသော အမှား အမျိုးအစားမျိုးများ၊ ဥပမာအားဖြင့် System ပိုင်းဆိုင်ရာ အမှားများအား Error ကလပ်စ်၏ ဆင့်ပွားကလပ်စ်များဖြင့် အသုံးပြုပြီး၊ ပရိုဂရမ်မှ မျှော်လင့်မထားသော ဖြစ်ရပ်များ ဖြစ်ပေါ်လာပါက Exception ကလပ်စ်၏ ဆင့်ပွားကလပ်စ်များကို အသုံးပြုပါသည်။

Exception များကို ဖြစ်ပေါ်စေတတ်သော API များကို အသုံးပြုရေးသားပါက ပရိုဂရမ်မာက သင့်တော်သလို လမ်းညွှန်များကို ရေးသားရန်လိုအပ်ပြီး၊ RuntimeException နှင့် ၎င်း၏ ဆင့်ပွား ကလပ်စ်များကို အသုံးပြုပါက မလိုအပ်ပါက လမ်းညွှန်များကို မရေးသားပဲ နေနိုင်ပါသည်။

ပရိုဂရမ်များကို ရေးသားရာတွင် လော့ဂျစ်အတွင်း လိုအပ်သလို အသင့်ပြင်ဆင်ထားသော Exception များကို အသုံးပြု၍ သော်၎င်း၊ မိမိကိုယ်တိုင် Exception ကလပ်စ်များအား အမွေဆက်ခံ၍ ကိုယ်ပိုင် Exception များကို ရေးသား အသုံးပြု၍ သော်၎င်း အမှားများကို အမျိုးမျိုး ထိမ်းချုပ် အသုံးပြုနိုင်ပါသည်။

အမှားများအား ထိမ်းချုပ်ရေးသားခြင်း

try catch ဝါကျ


Java ဘာသာရပ်တွင် အမှားများအား ထိမ်းချုပ်ရာတွင် try catch ဝါကျကို အသုံးပြုရန် လိုအပ်ပါသည်။ ရေးသားပုံမှာ try ဘလော့ (Block) ထဲတွင် အမှား ဖြစ်ပေါ်စေတတ်သော လော့ဂျစ်များကို ရေးသားပြီး catch ဖြင့် ဖြစ်ပေါ်တတ်သော အမှား ကလပ်စ်များကို ဖမ်းယူကာ Block အတွင်းတွင် သင့်တော်သလို လမ်းညွှန် ရေးသားနိုင်ပါသည်။

try {
    လော့ဂျစ်များ
} catch ( အမှား Object) {
    အမှား လမ်းညွှန်
}

အထက်ဖော်ပြပါ Sample1.java ကို ပြုပြင်ရေးသားကြည့်ပါမည်။

Sample1.java

public class Sample1 {
    public static void main(String [] args) {
        try {
            String param = args[0];
            System.out.println(param);
        } catch (Exception e) {
            System.err.println("Exit Because : " + e.toString());
        }
    }
}

အမှားများအား ခွဲခြား၍ catch လုပ်ခြင်း


နမှုနာ အဖြစ် ပါရာမီတာများကို ပေါင်းပေးနိုင်သော ပရိုဂရမ်တစ်ခုကို ရေးသားကြည့်ပါမည်။

Sample2.java

public class Sample2 {

    public static void main(String[] args) {
        try {
            int result = 0;
            String message = "";
            for (String s : args) {
                result += Integer.parseInt(s);
                message = message + " + " + s;
            }
            message = message.substring(2,message.length());
            message = message + " = ";
            System.out.println(message + result);
        } catch (Exception e) {
            System.err.println("Exit because of " + e.toString());
        }
    }
}

အထက်ပါ ပရိုဂရမ်အား ကွန်ပိုင်းလုပ်၍ စမ်းသပ်ကြည့်ပါမည်။

ဦးစွာ java Sample2 1 2 3 ဟု ခေါ်ယူကြည့်သောအခါ 1 + 2 + 3 = 6 ဟု မှန်ကန်စွာ ဖော်ပြနိုင်ပါသည်။ တဖန် ပါရာမီတာမပါပဲ java Sample2 ဟု ခေါ်ပါက StringIndexOutOfBoundsException ကို ဖြစ်ပေါ်စေပြန်သည်။ နောက်ဆုံးတွင် java Sample2 a b ဟု ကိန်းဂဏာန်းမဟုတ်သော ပါရာမီတာကို အသုံးပြုပါက NumberFormatException ကို ဖြစ်ပေါ်စေသည်ကို တွေ့ရပါသည်။

ဤနေရာတွင် ပါရာမီတာမပါသည့်အခါတွင်ရော ပါရာမီတာ မှားသည့်အခါများမှာပါ တစ်ပုံစံတည်း ရေးသားနေသည်မှာ သိပ်ပြီးအစဉ်ပြေလှသည်မဟုတ်ပေ။ ပါရာမီတာ မပါလျှင် မပါဘူး၊ ကိန်းပုံစံမဟုတ်လျှင် မဟုတ်ဘူးဟု ခွဲခြားဖော်ပြသင့်ပေသည်။ ထိုအခါမျိုးတွင် Exception များကို အကြိမ်ကြိမ် Catch လုပ်ခြင်းဖြင့် အောက်ပါအတိုင်း ပြုပြင်ရေးသားနိုင်ပါသည်။

Sample2.java

public class Sample2 {

    public static void main(String[] args) {
        try {
            int result = 0;
            String message = "";
            for (String s : args) {
                result += Integer.parseInt(s);
                message = message + " + " + s;
            }
            message = message.subString(2,message.length());
            message = message + " = ";
            System.out.println(message + result);
        } catch (StringIndexOutOfBoundsException e) {
            System.err.println("Please set parameters to add.");
        } catch (NumberFormatException e) {
            System.err.println("Please use numbers as parameter.");
        }
    }
}

အထက်ပါ နမှုနာထဲတွင် StringIndexOutOfBoundException နှင့် NumberFormatException တို့အား ခွဲခြား၍ Catch လုပ်ပြီး ကိုယ်စီ လမ်းညွှန်စာကြောင်းများကို ရေးသားနေပါသည်။ လက်တွေ့စမ်းသပ် ကြည့်ပါဦးမည်။

အထက်ပါအတိုင်း အမှားများအပေါ်တွင်မှုတည်၍ အမျိုးမျိုး ခွဲခြား လမ်းညွှန်မှု့ကို ပေးနိုင်သည်ကို တွေ့ရပါမည်။


Multi Catch


Java 7 အရောက်တွင် Exception များကို ပူးတွဲ၍ Catch လုပ်နိုင်သော ဝါကျကို ပြင်ဆင်လာခဲ့ပါသည်။ ရေးသားပုံမှာ အောက်ပါအတိုင်းဖြစ်၏။

public class Sample2 {

    public static void main(String[] args) {
        try {
            int result = 0;
            String message = "";
            for (String s : args) {
                result += Integer.parseInt(s);
                message = message + " + " + s;
            }
            message = message.subString(2,message.length());
            message = message + " = ";
            System.out.println(message + result);
        } catch (StringIndexOutOfBoundsException |
                ArrayIndexOutOfBoundsException e) {
            System.err.println("Please set parameters to add.");
        } catch (NumberFormatException e) {
            System.err.println("Please use numbers as parameter.");
        }
    }
}

အထက်ပါ နမှုနာထဲတွင် ArrayIndexOutOfBoundsException နှင့် StringIndexOutOfBoundsException တို့ကို | ကိုအသုံးပြု၍ တစ်နေရာထဲတွင် ပေါင်း၍ Catch လုပ်နိုင်သည်ကို တွေ့ရပါသည်။ Java 7 မတိုင်ကဆိုပါက အထက်ပါ Exception များ၏ အထက်ရှိ IndexOutOfBoundsExceptionကို Catch လုပ်ပြီး သုံးနေရပါသည်။ သို့ရာတွင် IndexOutOfBoundsException ကို Catch လုပ်ပါက လိုအပ်သော Exception ၂ခုအပြင် IndexOutOfBoundsException ၏ Sub Class ဆိုပါက အားလုံးကို catch လုပ်နေပါသည်။ ဤကဲ့သို့ Multy Catch ကို အသုံးပြုခြင်းအားဖြင့် လိုအပ်သည့် Exception များကိုသာ ရွေးချယ်၍ Catch လုပ်နိုင်လာပါသည်။

အမှားအဖြစ် အသုံးပြုခြင်း

ပရိုဂရမ်များအားရေးသားရာတွင် မျှော်လင့်မထားသော အခြေအနေကို ကြိုတင်သိရှိပါက ဆက်လက်၍ အလုပ်ပေးမလုပ်တော့ပဲ၊ အမှားအဖြစ် Throw လုပ်ခြင်းဖြင့် မလိုလားအပ်သော အမှားများကို တားစီးနိုင်ပါသည်။ Exception များကို Throw လုပ်ရာတွင် ပြင်ဆင်ထားသော Exception များကို တိုက်ရိုက်အသုံးပြု၍၎င်း၊ ထို Exception များအား အမွေဆက်ခံ၍ ကိုယ်ပိုင် Exception များကို ရေးသား၍၎င်း အမှားများကို Control လုပ်နိုင်ပါသည်။

အထက်ပါနမှုနာတွင် ပါရာမီတာသည် ၂ခုအထက်ရှိမှသာ ပေါင်းနိုင်မည်ဖြစ်သည်။ ပါရာမီတာ တစ်ခုဆိုပါက ပေါင်းနိုင်မည် မဟုတ်ပါ။ ထို့ကြောင့် ပါရာမီတာသည် ၂ခုအောက်ဆိုပါက အမှားကို Throw လုပ်ရန် ပြန်ပြင်ရေးပါမည်။ ဤနေရာတွင် RuntimeException ကို Extends လုပ်ထားသော ကိုယ်ပိုင် Exception ကို အသုံးပြု၍ Throw လုပ်ပါမည်။

public class Sample3 {
    public static void main(String[] args) {
        try {

            if (args.length < 2)
                throw new MyException();

            int result = 0;
            String message = "";
            for (String s : args) {
                result += Integer.parseInt(s);
                message = message + " + " + s;
            }
            message = message.substring(2, message.length());
            message = message + " = ";
            System.out.println(message + result);
        } catch (MyException e) {
            System.out.println(e.getMessage());
        } catch (ArrayIndexOutOfBoundsException
                | StringIndexOutOfBoundsException e) {
            System.err.println("Please set parameters to add.");
        } catch (NumberFormatException e) {
            System.err.println("Please use numbers as parameter.");
        }
    }
}

class MyException extends RuntimeException {
    private static final long serialVersionUID = 1L;

    public MyException() {
        super("Please set 2 or more parameters for add.");
    }
}

အထက်ပါ ကုဒ်များ၏ စာကြောင်း ၅နှင့် ၆တွင် အကယ်၍ args.length < 2 ဟုရေးထားပါသဖြင့် ပါရာမီတာသည် ၂ ထက် သေးငယ်ပါက အောက်တွင် throw new MyException() ဟု ကိုယ်ပိုင် Exception ကို Throw လုပ်နေပါသည်။


စာကြောင်း ၂၈မှစ၍ MyException ကို ရေးသားထားပြီး၊ Constructor ထဲတွင် super("Please set 2 or more parameters for add.") ဟု Super Class အား Message ဖြည့်စွက်နေပါသည်။ ဤနည်းအားဖြင့် အမှားဖြစ်ရခြင်း Message ကို ဖြည့်စွက်ပြီး ဖြစ်စေပါသည်။

စာကြောင်း ၁၇ တွင် MyException ကို catch လုပ်နေပြီး၊ အထဲတွင် e.getMessage() ဟု Exception မှ အမှား Message ကို ထုတ်ယူနေပါသည်။ နမှုနာအား ကွန်ပိုင်းလုပ်၍ စမ်းသပ်ကြည့်ပါမည်။

java Sample3 ဟု ပါရာမီတာမပါပဲ ခေါ်ကြည့်သောအခါ ပါရာမီတာ၏ အရေအတွက်သည် ၂ခုအောက် ဖြစ်ပါ၍ MyException တွင် သတ်မှတ်ထားသော Error Message ကို မှန်ကန်စွာ ဖော်ပြပေးနိုင်သည်ကို တွေ့ရပါလိမ့်မည်။

Basic Programming ခေါင်းစဉ်ဖြင့် Java Programming ၏ အခြေခံသဘောတရားများကို ဖော်ပြလာခဲ့သည်မှာ ၈ ကြိမ်မြောက်ကို ရောက်ရှိခဲ့ပြီဖြစ်၏။ ပရိုဂရမ်ဆိုသည်မာ အဘယ်နည်းမှအစပြု၍၊ ကိန်းရှင်များ၊ ကွန်တရိုးများ၊ ကလပ်စ်နှင့် လုပ်ဆောင်ချက်များ၊ မျိုးရိုးဆက်ခံခြင်း နှင့် အင်တာဖေစ် အကြောင်း၊ နောက်ဆုံးတွင် Exception အကြောင်းကို ဖော်ပြခဲ့၏။

Java ပရိုဂရမ်ကို ရေးသားရန် အခြေခံမှာ ပြည့်စုံပြီဖြစ်၏။ နိုင်ငံခြား ဘာသာအား လေ့လာသူ တစ်ယောက်နှင့် နှိုင်းယှဉ်လျှင် စကားပြောနည်းကို လေ့လာခဲ့ပြီး အဆင့်နှင့် တူပါသည်။ စကားတကယ် ပြောတတ်ရန်မှာ စကားလုံးများကို လေ့လာရန်နှင့် စကားပြောကျင့်ရန် လိုအပ်ပါသေးသည်။ Java ဘာသာရပ်တွင် စကားလုံးများမှာ API များဖြစ်ကြသည်။ Basic Programming ခေါင်းစဉ်ကို ဤနေရာတွင် ရပ်တန့်မည် ဖြစ်သော်လည်း Java ပရိုဂရမ်မာ တစ်ယောက်အနေနှင့် သိထားသင့်သော API များအကြောင်းကို Easy Java API ခေါင်းစဉ်ဖြင့် ဆက်လက် ဖော်ပြသွားပါဦးမည်။

လေးစားစွာဖြင့်

မင်းလွင်

Interface

တကယ်ဆိုလျှင် ဤအင်တာဖေစ် အကြောင်းကို ပြီးခဲ့သော မျိုးရိုးဆက်ခံမှု့ အကြောင်းနှင့် တွဲကာ ရေးသားရန် ရည်ရွယ်ထားခဲ့ပါသည်။ မျိုးရိုးဆက်ခံခြင်းကို အသုံးပြုခြင်းအားဖြင့် ကလပ်စ် အချင်းချင်းကြားတွင် ပတ်သက်မှု့များကို ဖြစ်ပွားစေနိုင်ခြင်း၊ Java ဘာသာရပ်တွင် ကလပ်စ်တစ်ခုသည် တစ်ခုတည်းသော Super Class မှသာ မျိုးရိုးဆက်ခံခွင့်ရှိခြင်း အစရှိသည့် အားနည်းချက်များရှိကြောင်းကို ဖော်ပြခဲ့၏။

မျိုးရိုးဆက်ခံခြင်း၏ အားနည်းချက်များအား အင်တာဖေစ်ကို အသုံးပြုခြင်းအားဖြင့် ဖြေရှင်းနိုင်ကြောင်း ဖော်ပြရန် ရည်ရွယ်ခဲ့သော်လည်း၊ မျိုးရိုးဆက်ခံခြင်း အကြောင်းကို ရေးရင်း အတော်လေးကို ရှည်သွားပါသည်။ ထို့ကြောင့်　အင်တာဖေစ် အကြောင်းကို နောက်တစ်ခန်းခွဲ၍ ရေးသားရန် ဖြစ်လာခဲ့ပါသည်။ ဤတစ်ခန်း ပြီး၍ Exception များအကြောင်းကို ဖော်ပြပြီးလျှင် အခြေခံ Java အကြောင်းကို တစ်ခန်းရပ်ပါမည်။

Java နှင့်ပတ်သက်၍ Easy Java API ဟူသော ခေါင်းစဉ်ဖြင့် Java ပရိုဂရမ်များကို ရေးသားရာတွင် မရှိမဖြစ်လိုအပ်သော API များအကြောင်းကို ဆက်လက်၍ ရေးသားဖော်ပြသွားပါဦးမည်။

Interface ဆိုသည်မှာ

အင်တာဖေစ် ဆိုသည်မှာ Object တစ်ခု၏ စွမ်းဆောင်နိုင်မှု့ကို သက်မှတ်ပေးနိုင်သော ကလပ်စ် တစ်မျိုးဖြစ်၏။ အလွယ်ဆုံး ဆိုရမည် ဆိုလျှင် Object မှ အသုံးပြုနိုင်သော လုပ်ဆောင်ချက်များနှင့်၊ ကိန်းသေ များကို စုစည်းဖော်ပြထားခြင်း ဖြစ်ပါသည်။

အင်တာဖေစ်သည် ယခင်တစ်ခေါက် ဖော်ပြခဲ့သော Abstract Class နှင့် အလွန်ဆင်ပါသည်။ အင်တာဖေစ်သည် မိမိကိုယ်တိုင်မှ instance လုပ်၍မရနိုင်ပေ။ တဖန် အင်တာဖေစ်အား ပံ့ပိုးထားသော ကလပ်စ် တစ်ခုသည်၊ ထိုအင်တာဖေစ်တွင် သက်မှတ်ထားသော လုပ်ဆောင်ချက်များအား Override လုပ်ပြီး ရေးသားရန် လိုအပ်ပါသည်။

အထက်ပါအချက်များကို ကြည့်ရုံဆိုပါက အင်တာဖေစ်နှင့် Abstract Class သည် အတူတူလို့တောင် ထင်နိုင်ပါသည်။ သို့ရာတွင် ကလပ်စ်တစ်ခုမှ အင်တာဖေစ် အမျိုးမျိုးကို ပံ့ပိုးနိုင်ခြင်း၊ အင်တာဖေစ်များကို ပံ့ပိုးခြင်းသည် ကလပ်စ်များအကြားတွင် မှီခိုမှု့ကို မဖြစ်ပွားစေခြင်း အစရှိသည့် အချက်များက အင်တာဖေစ်နှင့် Abstract Class တို့၏ ကွာခြားချက်များ ဖြစ်ကြပါသည်။

အကျဉ်းချုပ်ဆိုရမည် ဆိုလျှင် အောက်ပါအတိုင်းဖြစ်သည်။

• အင်တာဖေစ် တစ်ခုမှ Object ကို တိုက်ရိုက် instance လုပ်နိုင်ခွင့်မရှိပါ။
• အင်တာဖေစ်အား ပံ့ပိုးထားသော ကလပ်စ်သည် ထိုအင်တာဖေစ် တွင်သတ်မှတ်ထားသော လုပ်ဆောင်ချက်များအား ဖြည့်စွက်ရေးသားရန် လိုအပ်ပါသည်။
• အင်တာဖေစ်တွင် သတ်မှတ်ရေးသားထားသော ကိန်းရှင်များသည်၊ ပြုပြင် ပြောင်းလည်း၍မရနိုင်သော ကိန်းသေများ ဖြစ်ကြပါသည်။

မှတ်ချက်

Java ဘာသာရပ်တွင် Super Class တစ်ခုတည်းမှသာ မျိုးရိုးဆက်ခံခွင့်ရရှိခြင်းသည်၊ အကဲ၍ အမျိုးတူ အမည်တူလုပ်ဆောင်ချက်များကို Super Class များက ပိုင်ဆိုင်ခဲ့ပါက၊ Sub Class ထဲတွင် မည်သည့် လုပ်ဆောင်ချက်ကို အသုံးပြုသင့်သည်ကို ကွန်ပိုင်းလာမှ ဝေခွဲ၍ မရသောကြောင့် ဖြစ်ပါသည်။

Interface အား သတ်မှတ်ရေးသားပုံ

Interface အား ရေးသားပုံ

အင်တာဖေစ်အား ရေးသားရာတွင် interface ဟု အရှေ့တွင် ရေးသားရပါမည်။ အတွင်းပိုင်းတွင်မှု အသုံးပြုလိုသည့် ကိန်းရှင်များနှင့် လုပ်ဆောင်ချက် သတ်မှတ်ချက်များကို ရေးသားရုံသာပင် ဖြစ်၏။

Scanner.java

import java.util.List;

public interface Scanner {
 public List<Stringt> scanLines();
 public long getSize();
}

အထက်ပါ နမှုနာထဲတွင် Scanner အင်တာဖေစ်ကို ရေးသားထားပါသည်။ Scanner အင်တာဖေစ်တွင် စာကြောင်းများကို ဖတ်ယူနိုင်သော scanLines ဟုသည့် လုပ်ဆောင်ချက်နှင့်၊ ဆိုဒ်ကို ဖော်ပြပေးနိုင်သော getSize လုပ်ဆောင်ချက်ကို ပိုင်ဆိုင်ပါသည်။ Scanner အင်တာဖေစ်ကို ပံ့ပိုးလိုသော ကလပ်စ်သည် အထက်ပါ လုပ်ဆောင်ချက်များကို ဖြည့်စွက်ရေးသားရန် လိုအပ်ပါသည်။


Interface အား ပံ့ပိုးသော Class အား ရေးသားပုံ

အထက်တွင် ဖော်ပြခဲ့သည့်အတိုင်း အင်တာဖေစ်များမှ တိုက်ရိုက် instance လုပ်၍မရနိုင်ပေ။ အင်တာဖေစ်၏ Object များကို အသုံးပြုလိုပါက၊ အင်တာဖေစ်ကို ပံ့ပိုးပေးထားသော Class များကို instance လုပ်ယူမှ ရနိုင်မည် ဖြစ်ပါသည်။ ကလပ်စ်တစ်ခုမှ အင်တာဖေစ်အား ပံ့ပိုးရန်မှာ implements စကားလုံးကို အသုံးပြုရန် လိုအပ်ပါသည်။ ရေးသားပုံမှာ အောက်ပါအတိုင်းဖြစ်၏။

Scanner.java

class MyScanner implements Scanner {

 @Override
 public List<String> scanLines() {
  // TODO Write about scan
  return null;
 }

 @Override
 public long getSize() {
  // TODO write to return size of file
  return 0;
 }
}

အထက်ပါအတိုင်း၊ အင်တာဖေစ်အား ပံ့ပိုးမည့်ကလပ်စ်၏ အမည်ရဲ့နောက်တွင် implements စကားလုံးနှင့် ပံ့ပိုးမည့် အင်တာဖေစ်၏ အမည်ကို ရေးသားရပါမည်။ ဤနမှုနာတွင် အင်တာဖေစ် တစ်ခုကိုသာ အသုံးပြုထားသော်လည်း၊ အင်တာဖေစ် အမည်များကို ကော်မာခံ၍ ရေးသားသွားပါက တစ်ခုထက်မက အင်တာဖေစ်များကို ပံ့ပိုးနိုင်မည် ဖြစ်ပါသည်။ သို့ရာတွင် ကလပ်စ် အတွင်းတွင် ပံ့ပိုးထားသော အင်တာဖေစ်များတွင် သတ်မှတ်ထားသည့် လုပ်ဆောင်ချက်များကို ဖြည့်စွက် ရေးသားရန် လိုအပ်ပါသည်။

Interface များ၏ မျိုးရိုးဆက်ခံမှု့

Objected Oriented ၏ မျိုးရိုးဆက်ခံမှု့သည်လည်း အင်တာဖေစ်များတွင် အသုံးပြုနိုင်ပါသည်။ Class များတွင် အသုံးပြုခဲ့သကဲ့သို့ပင် extends ကို အသုံးပြု၍ အင်တာဖေစ်များတွင် မျိုးရိုးဆက်ခံခြင်း သဘောတရားကို အသုံးပြုနိုင်ပါသည်။ လက်တွေ့ရေးသားကြည့်ပါမည်။

ScannerTest.java

import java.io.IOException;
import java.nio.charset.Charset;
import java.nio.file.FileSystems;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.attribute.BasicFileAttributeView;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.List;

interface Scanner {
 public long getSize();
}

interface TextScanner extends Scanner {
 public List<String> scanLines();
}

class MyScanner implements TextScanner {

 private List<String> list;
 private long size;

 public MyScanner(String name) throws IOException {
  // Setting list
  Path path = FileSystems.getDefault().getPath(name);
  this.list = Files.readAllLines(path, Charset.defaultCharset());
  
  // Setting size
  BasicFileAttributeView view = Files.getFileAttributeView(path,
    BasicFileAttributeView.class);
  BasicFileAttributes attributes = view.readAttributes();
  this.size = attributes.size();
 }

 @Override
 public List<String> scanLines() {
  return this.list;
 }

 @Override
 public long getSize() {
  return this.size;
 }
}

public class ScannerTest {
 
 public static void main(String[] args) {
  try {
   TextScanner scanner = new MyScanner("ScannerTest.java");
   System.out.println("Size of file : " + scanner.getSize());
   System.out.println("Count of Lines : " + scanner.scanLines().size());
  } catch (IOException e) {
   e.printStackTrace();
  }
 }
}

အထက်ပါ နမှုနာထဲတွင် Scanner နှင့် TextScanner ဟုအမည်ရသော အင်တာဖေစ် နှစ်ခုနှင့်၊ MyScanner ဟု အမည်ရသော ကလပ်စ် တစ်ခုတို့ပါဝင်ပါသည်။ Scanner အင်တာဖေစ်တွင် ဖတ်ယူထားသော ပမာဏကို ဖော်ပြနိုင်သည့် getSize လုပ်ဆောင်ချက်ကို ပိုင်ဆိုင်ပြီး၊ TextScanner မှာတော့ ဖတ်ယူထားသော စာကြောင်းများကို ရယူနိုင်သည့် scanLines လုပ်ဆောင်ချက်ကို ပိုင်ဆိုင်စေပြန်သည်။

တဖန် TextScanner သည် Scanner အမျိုးအစားအင်တာဖေစ် အဖြစ်အသုံးပြုလိုပါ၍ extends ကို အသုံးပြုကာ Scanner အင်တာဖေစ်၏အမွေကို ဆက်ခံစေပါသည်။ ဤနည်းအားဖြင့် TextScanner ကို အသုံးပြုပါက getSize ကော scanLines ကိုပါ အသုံးပြုနိုင်မည် ဖြစ်၏။

MyScanner ကလပ်စ်သည် TextScanner အင်တာဖေစ်ကို ပံ့ပိုးထားသော ကလပ်စ်ဖြစ်ပါသည်။ ထို့ကြောင့် TextScanner နှင့် ၎င်း၏ Super Class ဖြစ်သော Scanner တွင် သတ်မှတ်ထားသော getSize နှင့် scanLines များကို override လုပ်ကာ ဖြည့်စွက် ရေးသားရန်လိုအပ် ပါသည်။

MyScanner ၏ ကွန်စတရက်တာတွင် Java 7 ၏ Nio2 ကို အသုံးပြုကာ ဖိုင်၏ပမာဏနှင် ဖိုင်တွင်ပါဝင်သော စာကြောင်းများကို ဖတ်ယူ၍၊ private အချက်အလက်များ ဖြစ်ကြသော size နှင့် lines တွင် အစားထိုး သိမ်းဆည်း ထားပါသည်။ ဤနည်းအားဖြင့် getSize ကို ခေါ်ယူသောအခါ size ကို၎င်း၊ scanLines ကို ခေါ်ယူသောအခါ lines ကို၎င်း ပြန်ပေးမည်ဖြစ်သည်။

တဖန် ScannerTest#main လုပ်ဆောင်ချက်ထဲတွင် TextScanner အင်တာဖေစ်၏ Object ကို MyScanner ကလပ်စ်မှတဆင့် instance လုပ်ပြီး၊ စာကြောင်း ၅၁နှင့် ၅၂တွင် အသီးသီး TextScanner Object မှတဆင့် getSize နှင့် ScanLines ၏ စာကြောင်းရေကို ဖော်ပြနိုင်သော List#size ကို ခေါ်ယူနေပါသည်။ ဤနမှုနာထဲတွင် scanner.scanLines().size() ဟု ရေးသားထားသည်မှာ scanner.scanLines() ဖြင့် List Object ကို ရရှိပြီး၊ ထို List ၏ size လုပ်ဆောင်ချက်ကို ဆက်လက် ခေါ်ယူခြင်း ဖြစ်ပါသည်။

အထက်ပါ ကုဒ်များအား ကွန်ပိုင်းလုပ်ကာ Run ကြည့်ပါမည်။

ဆက်ပါဦးမည်။ လေးစားစွာဖြင့်

မင်းလွင်

Class များနှင့် မျိုးရိုးဆက်ခံခြင်း

မျိုးရိုးဆက်ခံခြင်း

Java သည် Object Oriented ၏ သဘောတရားကို အခြေခံသော ပရိုဂရမ်မင်းဘာသာရပ် တစ်ခုဖြစ်၏။ OOP ၏ အခြေခံ သဘောတရား တစ်ခုဖြစ်သော မျိုးရိုးဆက်ခံခြင်းအား Java ဘာသာရပ်တွင် အသုံးပြု နိုင်ပါသည်။

Object Oriented ၏ သဘောတရားထဲတွင် Objectတစ်ခုအား အခြားသော Object တစ်ခုမှ ဆင့်ပွား၍ တည်ဆောက်နိုင်၏။ ဤကဲ့သို့ ဆင့်ပွားတည်ဆောက်ထားသော Object သည် မှုရင်း Object ၏ ပိုင်ဆိုင်မှု့များကို ဆက်လက်ပိုင်ဆိုင်နိုင်၏။ ဤကဲ့သို့ Object တစ်ခုကို အခြားသော Object တစ်ခုမှ ဆင့်ပွား တည်ဆောက်ခြင်းနှင့် မှုရင်း Object တစ်ခု၏ ပိုင်ဆိုင်မှု့များကို လက်ဆင့်ကမ်းပိုင်ဆိုင်နိုင်ခြင်း တို့ကို မျိုးရိုးဆက်ခံခြင်း ဟုခေါ်ဆိုပါသည်။

Java ပရိုဂရမ်မင်းဘာသာရပ်သည် Class အခြေခံ ပရိုဂရမ်မင်းဘာသာရပ် တစ်ခု ဖြစ်သောကြောင့် မျိုးရိုးဆက်ခံခြင်းကို Class အဆင့်တွင် ထည့်သွင်းထားပါသည်။ Class တစ်ခုသည် Object တစ်ခု၏ ပိုင်ဆိုင်သင့်သော အချက်အလက်များကို သတ်မှတ်ပေးရုံသာမှက၊ Object တစ်ခု၏ ပတ်သက်မှု့များကိုလည်း ဖော်ပြပေးနေပါသည်။


extends


မျိုးရိုးဆက်ခံခြင်း သဘောတရား၌ ပင်မမှုရင်း Class အား Super Class ဟု ခေါ်ဆို၍၊ Super Class မှ တဆင့် ဆင့်ပွားတည်ဆောက်ထားသော အမွေဆက်ခံယူမည့် Class အား Sub Class ဟု ခေါ်ဆိုပါသည်။ Java ဘာသာရပ်တွင် မျိုးရိုးဆက်ခံခြင်းကို extends စကားလုံးကို အသုံးပြု၍ ရေးသားနိုင်ပါသည်။

public class Test {

 public static void main(String[] args) {
  MySuper sup = new MySuper("Super Class");
  System.out.println("MySuper#getData -> " + sup.getData());
  
  MySub sub = new MySub("Sub Class");
  System.out.println("MySub#getData -> " + sub.getData());
  System.out.println("MySub#getSub_data -> " + sub.getSub_data());
 }
}

class MySuper {

 private Object data;
 
 public MySuper(Object data) {
  this.data = data;
 }
 
 public Object getData() {
  return this.data;
 }
 
}

class MySub extends MySuper {
 
 private Object sub_data;
 
 public MySub(Object data) {
  super(data);
  this.sub_data = String.valueOf(super.getData()).toUpperCase();
 }
 
 public Object getSub_data() {
  return this.sub_data;
 }
}

အထက်ပါ ကုဒ်များအတွင်းတွင် စာကြောင်း ၁၃မှစ၍ ၂၅အထိသည် MySuper ကလပ်စ် အကြောင်းကို ရေးသားထားပါသည်။ MySuper ကလပ်စ်တွင် data ကို ပိုင်ဆိုင်၍၊ getData ဖြင့် data ကို ရရှိနိုင်ပါသည်။

တဖန် စာကြောင်း ၂၇မှ ၃၈သည် MySub ကလပ်စ်ကို ရေးသားထားပါသည်။ MySub သည် MySuper ကို extends လုပ်ထားပါသဖြင့် MySuper ၏ အမွေကို ဆက်ခံထားသော Sub Class တစ်ခုဖြစ်ပါသည်။ MySub တွင် sub_data ကို ပိုင်ဆိုင်ပြီး၊ Constructor ထဲတွင် super.getData() ဖြင့် Super Class ၏ data ကို ရယူပြီး၊ String#toUpperCase လုပ်ဆောင်ချက်ဖြင့် စာလုံးအကြီးကို ပြောင်းကာ sub_data တွင်အစားထိုးပါသည်။ MySub#getSub_data လုပ်ဆောင်ချက်ကို အသုံးပြုခြင်းအားဖြင့် sub_data ကို ရရှိနိုင်ပါသည်။

အထက်ပါ ကုဒ်များအား ကွန်ပိုင်းလုပ်၍ အလုပ်ခိုင်းကြည့်ပါက ကွန်ဆိုးတွင် အောက်ပါအတိုင်း ဖော်ပြပေးနိုင်သည်ကို တွေ့ရပါလိမ့်မည်။

MySuper#getData -> Super Class
MySub#getData -> Sub Class
MySub#getSub_data -> SUB CLASS

စာကြောင်း ၈ ကိုကြည့်ပါက၊ MySub ၏ instance ဖြစ်သော sub မှတဆင့် MySuper မှ အမွေ ဆက်ခံထားသော getData လုပ်ဆောင်ချက်ကို ခေါ်ယူနေသည်ကို တွေ့ရပါမည်။ ဤနည်းအားဖြင့် ကလပ်စ်တစ်ခု၏ ပိုင်ဆိုင်မှု့နှင့် လုပ်ဆောင်ချက်များအား ပြန်လည်အသုံးချနိုင်ရန် မျိုးရိုးဆက်ခံခြင်း သဘောတရားကို အသုံးပြုနိုင်ကြောင်း သိရှိနိုင်မည် ဖြစ်ပါသည်။


final class

ကလပ်စ်များအား ရေးသားရာတွင် အချို့သော ကလပ်စ်များအား ဆင့်ပွား ကလပ်စ်များ ဆက်လက်၍ တည်ဆောက် ခွင့်မပြု လိုသောအခါမျိုး ရှိပါလိမ့်မည်။ ထိုအခါမျိုးတွင် final စာလုံးကို အသုံးပြု၍ ရေးသားနိုင်ပါသည်။ ဥပမာအားဖြင့် အထက်ပါ နမှုနာ၏ စာကြောင်း ၁၃အား အောက်ပါအတိုင်း ပြင်ရေးသားပြီး ကွန်ပိုင်းလုပ်ကြည့်ပါမည်။

final class MySuper {

MySuper အား final class အဖြစ်သတ်မှတ်ပြီး၊ ကွန်ပိုင်းလုပ်ကြည့်သောအခါ အထက်ပါအတိုင်း MySuper သည် final class ဖြစ်ပါသောကြောင့် မျိုးရိုးဆက်ခံခွင့် မရှိကြောင်း ကွန်ပိုင်း Error ကို ဖြစ်ပေါ်စေမည် ဖြစ်ပါသည်။

မှတ်ချက်။ ။ အသုံးပြုနေသော Locale မှာ Japanese ဖြစ်နေပါသဖြင့် ကွန်ပိုင်း Message များသည် ဂျပန်စာဖြစ်နေသည်ကို သီးခံခွင့်လွှတ်စေလိုပါသည်။

မျိုးရိုးဆက်ခံခြင်း၏ အကျိုးနှင့် အဆိုး

မျိုးရိုးဆက်ခံခြင်းကို အသုံးပြုပါက ကလပ်စ် အဆင့်တွင် ရေးသားထားသော ကုဒ်များအား ပြန်လည် အသုံးပြုနိုင်သည်ကို တွေ့ခဲ့ရပါသည်။ ပြန်စဉ်းစားမည် ဆိုပါက Object Oriented အတွေးအခေါ်များ စတင် ခေတ်စားလာခဲ့ရခြင်းမှာ၊ အိုင်တီလုပ်ငန်းများ တိုးတက်ခါစ အချိန်ဖြစ်ပါသည်။ လုပ်ငန်းခွင်များတွင် သူ့ထက်ငါအပြိုင် အိုင်တီနည်းပညာများကို ထည့်သွင်းအသုံးပြုလာခဲ့ကြရာတွင် စစ္စတမ်များအား ရေးသားနိုင်သူ ပညာရှင်များမှာ လိုအပ်သည်ထက် အလွန်နည်းပါးခဲ့ပါသည်။ ရေးသားနိုင်သူ အလွန်နည်းပါခဲ့သော ထိုအခါမျိုးတွင် စစ္စတမ်တစ်ခုရေးတိုင်း အသစ် ပြန်လည် ရေးသားနေရသည်ထက်၊ ရေးပြီးသား ကုဒ်များအား ပြန်လည်အသုံးပြုနိုင်ရန် လိုအပ်လာခဲ့ပါသည်။

ပရိုဂရမ်အတွင်းတွင် အသုံးပြုမည့် အချက်အလက်များအား စုစည်း၍ လက်တွေ့ဘဝတွင် ရှိသော Object များအဖြင့် အစားထိုးပြီး၊ ထို Object များအား အပြန်အလှန် ခိုင်းစေခြင်းအားဖြင့် ရေးသားလိုသည့် လော့ဂျစ်အား အကောင်အထည်ဖော်စေသော Object Oriented ပရိုဂရမ်မင်း၏ အတွေးအခေါ်သည် ထိုခေတ်ထိုအခါနှင့် လွန်စွာကိုက်ညီသော နည်းပညာရပ်တစ်ခု ဖြစ်လာပါသည်။ အဘယ်ကြောင့်ဆိုသော် Class တစ်ခုအား တစ်ကြိမ်ရေးသားပြီး၊ ထို Class ၏ instance အား Object အဖြစ် နေရာတိုင်းတွင် အသုံးပြုနိုင်ခြင်းသည်၊ ရေးသားထားသော ကုဒ်များကို ပြန်လည်အသုံးချနိုင်ခြင်း ပင်ဖြစ်သောကြောင့် ဖြစ်ပါသည်။

ဤနည်းအားဖြင့် ၁၉၉၀ခုနှစ် ပိုင်းလောက်ကစ၍ လူသုံးစများလာသော Object Oriented ၏ အတွေးအခေါ်များသည်၊ ယနေ့ခေတ် အချိန်အခါ အရောက်တွင် C++, Java မှအစ Javascript၊ Python နှင့် PHP များအထိ အသုံးများသော ပရိုဂရမ်မင်း ဘာသာရပ်များတွင် အခြေခံ အတွေးအခေါ်အဖြစ် ဝင်ရောက် နေရာယူ ထားသည်ကိုတွေ့ရပါမည်။

ဆက်လက်၍ Object Oriented ၏ အခြေခံ အတွေးအခေါ်တစ်ခုဖြစ်သော မျိုးရိုးဆက်ခံခြင်း၏ ကောင်းကွက်၊ ဆိုးကွက်နှင့် အသုံးပြုသင့်သည့်နေရာများကို လက်တွေ့ နမှုနာများ ရေးသားရင်း ဆက်လက်လေ့လာသွားပါမည်။



လုပ်ဆောင်ချက်နှင့် ပိုင်ဆိုင်မှု့များကို ပြန်လည် အသုံးပြုနိုင်ခြင်း

ဥပမာအားဖြင့် Rectangle ဟု အမည်ရသော Class တစ်ခုရှိသည်ဟု စဉ်းစားကြည့်ပါမည်။ Rectangle တွင် length, width အစရှိသည့် အချက်အလက်များကို ပိုင်ဆိုင်ပြီး၊ Area ကို တွက်ယူနိုင်သော getArea လုပ်ဆောင်ချက်ကို ပိုင်ဆိုင်ပါသည်။ ဧရိယာကို တွက်ယူရာတွင်လည်း ထောင့်မှန်စတုဂံ ဖြစ်သောကြောင့် width * length ဖြင့် တွက်ချက်နိုင်ပါသည်။

တဖန် ဤနေရာတွင် Parallelogram ကို အသုံးပြုရန်လိုအပ်လာပါသည်။ ထိုအခါမျိုးတွင် Parallelogram ၏ ဧရိယာသည်လည်း base * height ဖြစ်ပါသောကြောင့် Rectangle ၏ လုပ်ဆောင်ချက်ကို ဆက်လက်အသုံးပြုသွားရုံဖြစ်၏။ ထို့ကြောင့် ဤနေရာမျိုးတွင် Parallelogram အား Rectangle ၏ Sub Class အဖြစ်တည်ဆောက်သွားပါမည်။

ShapeTest.java

class Ractangle {
 private double width = 0;
 private double length = 0;
 
 public Ractangle(double width, double length) {
  this.width = width;
  this.length = length;
 }
 
 public double getArea() {
  return this.length * this.width;
 }
}

class Parallelogram extends Ractangle {

 public Parallelogram(double width, double length) {
  super(width, length);
 }
}

public class ShapeTest {
 public static void main(String[] args) {
  calArea(new Ractangle(20, 12));
  calArea(new Parallelogram(24, 16));
 }
 
 public static void calArea(Ractangle ract) {
  System.out.println(ract.getClass().getName() + " : " + ract.getArea());
 }
}

အထက်ပါ ကုဒ်များအား ကွန်ပိုင်းလုပ်၍ အလုပ်ခိုင်းကြည့်ပါက အောက်ပါအတိုင်း တွေ့မြင်ရမည် ဖြစ်ပါသည်။

Ractangle : 240
Parallelogram : 384

Override နှင့် Polymorphism

အထက်ပါ နမှုနာမျိုးတွင် တြိဂံကိုလည်း အသုံးပြုလိုသည့်အခါရှိပါမည်။ သို့ရာတွင် တြိဂံသည် အခြေနှင့် အမြင့်ကို အသုံးပြုပါသော်လည်း ဧရိယာတွက်ကိန်းမှာ ထောင့်မှန်စတုဂံနှင့် မတူညီပါ။

ထိုအခါမျိုးတွင် Triangle သည် Rectangle ကို Extends လုပ်မည်ဖြစ်သော်လည်း getArea ကို မှု Rectangle ၏ getArea ကို မဟုတ်ပဲ မိမိကိုယ်ပိုင် getArea ကို အသုံးပြုရန်လိုအပ် လာပါသည်။ ထို့ကြောင့် getArea အမည်ဖြင့်လုပ်ဆောင်ချက်ကို ထပ်မံရေးသားပါသည်။ Java တွင် Super Class နှင့် Sub Class တွင် အမည်တူ လုပ်ဆောင်ချက်ကို ရေးသားထားပါက၊ Sub Class ကိုသာ အသုံးပြုမည် ဖြစ်သည်။

Super Class တွင်ရေးသားထားသော လုပ်ဆောင်ချက် တစ်ခုအား၊ Sub Class ဘက်တွင် ထပ်မံ ရေးသားချင်းကို Override ဟု ခေါ်ပါသည်။ ဤကဲ့သို့ တစ်ခုတည်းသော Class မှ ဆင်းသက်လာပြီး၊ ပုံစံအမျိုးမျိုး ပြောင်းလည်းနိုင်ခြင်းကို Polymorphism ဟုခေါ်ပါသည်။

ShapeTest.java

class Ractangle {
 private double width = 0;
 private double length = 0;
 
 public Ractangle(double width, double length) {
  this.width = width;
  this.length = length;
 }
 
 public double getArea() {
  return this.length * this.width;
 }
}

class Parallelogram extends Ractangle {

 public Parallelogram(double width, double length) {
  super(width, length);
 }
}

class Triangle extends Ractangle {

 public Triangle(double width, double length) {
  super(width, length);
 }
 
 @Override
 public double getArea() {
  return super.getArea()/2;
 }
}

public class ShapeTest {
 public static void main(String[] args) {
  calArea(new Ractangle(20, 12));
  calArea(new Parallelogram(24, 16));
  calArea(new Triangle(24, 16));
 }
 
 public static void calArea(Ractangle ract) {
  System.out.println(ract.getClass().getName() + " : " + ract.getArea());
 }
}

အထက်ပါ ကုဒ်များအား ကွန်ပိုင်းလုပ်ပြီး၊ အလုပ်လုပ်ခိုင်းကြည့်ပါက အောက်ပါအတိုင်း ဖော်ပြနိုင်ပါသည်။ ဖော်ပြပါအတိုင်း Triangle ကိုလည်း တွက်ချက်နိုင်သည်ကို တွေ့ရပါမည်။

Ractangle : 240.0
Parallelogram : 384.0
Triangle : 192.0

Abstract Class


တဖန် အထက်ပါ နမှုနာတွင် စက်ဝိုင်းကို ဖြည့်စွက်အသုံးပြုကြည့်ပါဦးမည်။ စဉ်းစားစရာ အချက်မှာ စက်ဝိုင်းသည် ထောင့်မှန်စတုဂံနှင့် ပိုင်ဆိုင်မှု့နှင့်ရော ဧရိယာ တွက်ချက်နည်းပါ မတူညီပေ။ ထို့ကြောင့် Rectangle အား Extends လုပ်၍ ရရှိသောအကျိုးမှာ ထင်သလုပ်ရှိမည် မဟုတ်။

သို့ရာတွင် ShapeTest ၏ static လုပ်ဆောင်ချက်ဖြစ်သော calArea ကို ပြန်လည်အသုံးပြုလိုပါသည်။ ShapeTest#calArea သည် ပါရာမီတာအဖြစ် Rectangle ၏ Object ကို ရယူပြီး၊ ထို Object ၏ getArea ကို ခေါ်ယူကာ ရရှိလာသော ရလဒ်အား ကွန်ဆိုးတွင် ရေးသား ဖော်ပြနေစေပါသည်။ တနည်းတွေးရမည် ဆိုလျှင် Rectangle နှင့် အမျိုးတူ Object ဖြစ်ရန် လိုအပ်ပြီး၊ getArea လုပ်ဆောင်ချက်ကို ပံ့ပိုးထားရန် လိုအပ်ပါသည်။

Java ဘာသာရပ်တွင် ဤအနေအထားမျိုး၌ Abstract Class ကို အသုံးပြု၍ ဖြေရှင်းနိုင်ပါသည်။ Abstract Class သည် လက်တွေ့ Object များကို ပြုလုပ်နိုင်ခြင်းမရှိသော ကလပ်စ် ဖြစ်ပြီး၊ ၎င်းအား အခြေခံသော Sub Class များကိုသာ ပြုလုပ်ခွင့်ရှိပါသည်။ Abstract Class တွင် Abstract လုပ်ဆောင်ချက်များကို ပိုင်ဆိုင်ခွင့်ရှိပါသည်။ Abstract လုပ်ဆောင်ချက်ဆိုသည်မှာ လုပ်ဆောင်ချက်၏ အမည်၊ ပါရာမီတာ နှင့် ရလဒ်ပုံစံများကို သာသတ်မှတ်ထားပြီး၊ လော့ဂျစ်များကိုမှု ရေးသားထားခြင်း မရှိပေ။ Sub Class မှ Abstract Class အား Extends လုပ်ရာတွင် အထက်ပါ Abstract လုပ်ဆောင်ချက်ကို Override လုပ်၍ လော့ဂျစ်များကို ရေးသားရပါမည်။

ဤနမှုနာတွင် Shape ဟုအမည်ရသော Abstract Class ကို ရေးသားပြီး၊ ၎င်းတွင် getArea ဟု အမည်ရသော Abstract လုပ်ဆောင်ချက်ကို ပိုင်ဆိုင်စေပါမည်။ တဖန် Rectangle နှင့် Circle ကို Shape အား Extends လုပ်စေပြီး၊ Rectangle နှင့် Circle ကို အမျိုးအစားတူ Object များအနေဖြင့် ShapeTest#calArea လုပ်ဆောင်ချက်တွင် အသုံးပြုစေမည် ဖြစ်ပါသည်။

ShapeTest.java

abstract class Shape {
 public abstract double getArea();
}

class Ractangle extends Shape{
 private double width = 0;
 private double length = 0;
 
 public Ractangle(double width, double length) {
  this.width = width;
  this.length = length;
 }
 
 @Override
 public double getArea() {
  return this.length * this.width;
 }
}

class Parallelogram extends Ractangle {

 public Parallelogram(double width, double length) {
  super(width, length);
 }
}

class Triangle extends Ractangle {

 public Triangle(double width, double length) {
  super(width, length);
 }
 
 @Override
 public double getArea() {
  return super.getArea()/2;
 }
}

class Circle extends Shape {
 
 private double radious;
 
 public Circle(double radious) {
  this.radious = radious;
 }

 @Override
 public double getArea() {
  return Math.PI * radious * radious;
 }
 
}

public class ShapeTest {
 public static void main(String[] args) {
  calArea(new Ractangle(20, 12));
  calArea(new Parallelogram(24, 16));
  calArea(new Triangle(24, 16));
  calArea(new Circle(24));
 }
 
 public static void calArea(Shape ract) {
  System.out.println(ract.getClass().getName() + " : " + ract.getArea());
 
}

အထက်ပါ နမှုနာထဲတွင် စာကြောင်း ၁ မှ ၃သည် Abstract Class Shape ဖြစ်ပြီး Abstract လုပ်ဆောင်ချက် getArea ကို ပိုင်ဆိုင်ပါသည်။ Rectangle နှင့် Circle တို့သည် အသီးသီး Shape အား Extends လုပ်ထားပြီး၊ ကိုယ်စီ getArea ကို override လုပ်နေကြပါသည်။ ဤနည်းအားဖြင့် Ractangle, Parallelogram, Triangle နှင့် Circle များသည် Shape အမျိုးအနွယ် ကလပ်စ်များဖြစ်ကြပြီး၊ အားလုံး ShapeTest#calArea လုပ်ဆောင်ချက်တွင် အသုံးပြုနိုင်ခြင်း ဖြစ်ပါသည်။

Ractangle : 240.0
Parallelogram : 384.0
Triangle : 192.0
Circle : 1809.5573684677208

သတိပြုရန် အချက်

မျိုးရိုးဆက်ခံမှု့နှင့် ပတ်သက်၍ နမှုနာများကိုပါ ရေးသားပြီး၊ လေ့လာခဲ့၏။ မျိုးရိုးဆက်ခံမှု့ဖြင့်၊ ရေးသားထားသော ကုဒ်များအား ပြန်လည်အသုံးပြုနိုင်ခြင်း၊ အုပ်စုတူ ကလပ်များကို သတ်မှတ်နိုင်ခြင်း အစရှိသည့် အကျိုးများကို ရရှိစေနိုင်ပါသည်။ သို့ရာတွင် မျိုးရိုးဆက်ခံမှု့ကြောင့် ကလပ်စ်တစ်ခုနှင့် တစ်ခု ပတ်သက် မှီခိုမှု့ကို ဖြစ်ပွားစေပြီး၊ ပြုပြင်ရခက်ခဲစေနိုင်ပါသည်။ ထို့ကြောင့် မျိုးရိုးဆက်ခံမှု့ကို အသုံးပြုရာတွင် ကုဒ်များအားပြန်လည် အသုံးပြုလိုခြင်း အကြောင်းတစ်ခုတည်းဖြင့် အသုံးမပြုသင့်ပေ။ အုပ်စုဖွဲ့အသုံးပြုလိုသည့်အခါများ၊ Framework များအား ရေးသားလိုသည့်အခါ များတွင် အသုံးပြုသင့်ပါသည်။

တဖန် Java ဘာသာရပ်တွင် Class တစ်ခုသည် တစ်ခုတည်းသော Super Class ကိုသာ Extends လုပ်နိုင်ပါသည်။ တစ်ခုသော Super Class အား Extends လုပ်ထားပါက အခြားသော ကလပ်စ်များအား ထပ်မံ၍ အမွေဆက်ခံနိုင်ခွင့် မရှိပေ။

Java နှင့် Polymorphism

ကျွှန်တော်​တို့ Easy Java ဟူသော ခေါင်းစဉ်​ဖြင့် Java ရဲ့ သဘော​တရား​များ၊ Java နဲ့ ပတ်သက်​တဲ့ OOP သဘော​တရား​များ​ကို၊ သုံး​သင့်​တဲ့​နေရာ မ​သုံး​သင့်​တဲ့​နေရာ များ​ကို​ခွဲ​ပြီး​လေ့​လာ​ခဲ့​၏။ ယခု​အကြိမ်​တွင် Java ကို အမြန်​ဆုံး​လေ့​လာ​ခြင်း ရဲ့ နောက်ဆုံး​အခေါက်​အနေ​နဲ့ OOP ရဲ့ အနှစ်သာရ ဖြစ်​တဲ့ Polymorphism အကြောင်း​ကို လေ့​လာ​သွား​ပါ​မည်။

ကျွှန်တော်​မှတ်မိ​ပါ​သေး​သည်။ ဤ​စကားလုံး Polymorphism အကြောင်း​ကို စ​သိ​ခဲ့​သည်မှာ ၁​၀​တန်း ဇီဝ​ဗေဒ​ဘာသာ သင်​ခန်း​စာ စာအုပ်​ထဲ​မှ​ဖြစ်​ပါ​သည်။ Ameba များ​၏ ပုံစံ​အမျိုး​မျိုး​ပြောင်း​လည်း​နိုင်​ပုံ​ကို Polymorphic ဟု​သုံး​နှုန်း​ထား​ခြင်း​ဖြစ်​၏။

Java နဲ့ OOP တွင် ဤ​စကားလုံး​ကို ပြန်ကြား​ရ​သော​အခါ၊ ဘယ်​လို​လုပ်​မှာ​လဲ ဟု​စဉ်းစား​ခဲ့​မိ​ပါ​သည်။ ဤ​အခန်း​သည် နည်း⁠နည်း​လည်း​ရှုပ်​၍၊ အသုံး​လည်း​ဝင်​ပါ​သ​ဖြင့် ကျွှန်တော်​တို့ Polymorphism ရဲ့ သဘော​တရား​နဲ့၊ Java က Polymorphism ကို ဘယ်​လို​ပုံဖော်​နေ​တယ်​ဆို​တာ​ကို အသေ​အချာ လေ့​လာ​မှတ်သား​ထား​ဖို့ လို​အပ်​ပေ​သည်။

လွယ်⁠လွယ်​နှင့် အဓိပ္ပါယ်​ဖွင့်​ရ​လျှင် လုပ်ဆောင်​ချက်​များ​မှာ​တူညီ​ပေ​မယ့်၊ ကွဲပြား​သော​လုပ်​ရပ်​များ​ကို Polymorphism ဟုခေါ်​သည် ဟု​ဆို​နိုင်​ပါ​သည်။ ဥ​မ​မာ​အား​ဖြင့် အောက်​ပါ​ပုံ​ပါ​အတိုင်း ခွေး​တစ်​ကောင်​ကို စကားပြော​ပါ​ဟု​ပြော​လျှင် ဝုတ်​ဝုတ် ဟု​အသံ​ထွက်​သ​လို၊ ကြောင်​တစ်​ကောင်​သည် ညှောင်⁠ညှောင်​ဟု အသံ​ထွက်​ပါ​လိမ့်​မည်။ ဤ​ကဲ့သို့​သော ပုံစံ​အမျိုး​မျိုး​ကွဲပြား​ပုံ​ကို Polymorphism ဟုခေါ်​ပါ​သည်။

ဟုတ်​ပြီ၊ ကျွှန်တော်​တို့ Java ဘက်​က​နေ​ပြန်​စဉ်းစား​ကြည့်​ကြ​ရအောင်။ Java မှာ လုပ်ဆောင်​ချက်​များ​ကို method နဲ့ ရေးသား​ပုံဖော်​နေ​ပါ​သ​ဖြင့်၊ တူညီ​သော Method တစ်​ခု​ဖြင့်၊ မ​တူညီ​သော​လုပ်ဆောင်​ချက်​များ​ကို လုပ်ဆောင်​ပေး​နိုင်​ခြင်း​ဟု အဓိပ္ပါယ်​ရ​ပါ​လိမ့်​မည်။ ကျွှန်တော်​တို့ လက်တွေ့ ရေး​ကြည့်​ကြ​ရအောင်။

Poly1.java

public class Poly1 {
    static void getName() {
        System.out.println("I am MinLwin");
    }

    static void getName(String name) {
        System.out.println("I am " + name);
    }

    public static void main(String [] args) {
        getName();
        getName("Chaw Su");
    }
}

အထက်​ပါ Poly1.java ကို ကွန်​ပိုင်း​လုပ်​ပြီး၊ အလုပ်​လုပ်​ခိုင်း​ကြည့်​ပါ​က အောက်​ပါ​အတိုင်း အလုပ်​လုပ်​မည်​ဖြစ်​သည်။ getNameဆို​တဲ့ လုပ်ဆောင်​ချက်​တစ်​ခု​တည်း​မှ အဖြေ​နှစ်​ခု​ရ​နေ​သည်​ကို တွေ့​မြင်​ရ​ပေ​မည်။ အဲ့​ဒီ​အတွက် Polymorphism ကို အသုံးပြု​နေ​သည်​ကို တွေ့​ရ​ပေ​မည်။

သေသေချာချာ​စဉ်းစား​ကြည့်​ပါ​က Overload နှင့်​ဘာ​မှ​မ​ကွာ​ပေ။ ဤသို့​ဆို​လျှင် Polymorphism ကို​အသုံးပြု​တဲ့ အကျိုး​ဘာ​များ​ရှိ​ပါ​ဦး​မည်​နည်း။ Polymorphism ၏​အကျိုး​ကျေးဇူး​များ​တွင် အမည်​တူ​ကို​အသုံးပြု​ခြင်း​အား​ဖြင့်၊ အမည်​အမျိုး​မျိုး​ကို​မှတ်​စရာ​မ​လို​ခြင်း၊ တ​ဖန် အမည်​တစ်​မျိုး​တည်း​ကို​သာ အသုံးပြု​ပါ​သ​ဖြင့် အမှား​နည်းပါး​စေ​ခြင်း အစ​ရှိ​တဲ့ ကျေးဇူး​များ​လည်း​ပါဝင်​ပေ​သည်။ သို့ရာတွင် အမည်​တူ​ကို​မ​သုံး​ပါ​လျှင် အဓိပ္ပါယ်​မ​ရှိ​ပါ။

Abstract Method and Abstract Class

ဤနေရာတွင် Java ဘာသာ​ရပ်​၌၊ abstract method (တကယ်​မ​ရှိ​ပေ​မယ့် ရှိ​သင့်​တဲ့​လုပ်ဆောင်​ချက်​များ) နဲ့ Override ကို အသုံးပြု​ခြင်း​အား​ဖြင့် Polymorphism ရဲ့ သဘော​တရား​တွေ​ကို အပြည့်​အဝ​ရ​ရှိ​စေ​ရန် စီစဉ်​ထား​ပေ​သည်။ ကျွှန်တော်​တို့ abstract class တစ်​ခု​ဖြစ်​တဲ့Pet ထဲ​မှာ လို​အပ်​တဲ့ လုပ်ဆောင်​ချက်​ဟာ greet() ရှိ​ကြောင်း abstract method တစ်​ခု​ဖြစ်​တဲ့ abstract void greet();ဟု​ရေးသား​ထား​ပါ​တယ်။ အဲ့​ဒီ​အတွက် Pet class ကို အမွေ​ဆက်ခံ​မည့် Class တွေ​မှာ ရှိ​သင့်​တဲ့ လုပ်ဆောင်​ချက် greet() ကို ရေးသား​ဖို့​လို​အပ်​ပါ​လိမ့်​မည်။
တ​ဖန် Cat နဲ့ Dog ကို Pet ရဲ့ အမွေ​ဆက်ခံ​စေ​ပြီးgreet() လုပ်ဆောင်​ချက်​ကို overrideလုပ်​ပြီး ရေးသား​စေ​ပါ​တယ်။

Poly2.java

public class Poly2 {
    static abstract class Pet {
        abstract void greet();
    }

    static class Cat extends Pet {
        void greet() {
            System.out.println("Meow");
        }
    }

    static class Dog extends Pet {
        void greet() {
            System.out.println("Woof");
        }
    }

    public static void main(String [] args) {
        Pet dog = new Dog();
        Pet cat = new Cat();
        
        dog.greet();
        cat.greet();
    }
}

ဤ​ကဲ့သို့ ရှိ​သင့်​တဲ့ Object ရဲ့ ပုံစံ​ကို abstract class မှာ​သက်​မှတ်​ခြင်း​အား​ဖြင့် အမျိုး​တူ Object အစုအဝေး​များ​ကို ရေးသား​နိုင်​မှာ​ဖြစ်​ပါ​တယ်။

Interface နှင့် Polymorphism

Abstract Method နဲ့ Override ကို အသုံးပြု​ခြင်း​အား​ဖြင့် Polymorphism ကို ပုံဖော်​နိုင်​ကြောင်းဖော်​ပြ​ခဲ့​ပြီး​ဖြစ်​သည်။ သို့ရာတွင် Java ၏​အမွေ​ဆက်ခံ​မှု့​တွင် ပြဿနာ​တစ်​ခု​ရှိ​ပါ​သေး​သည်။ ထို​အရာ​မှာ တစ်​ခု​တည်း​သော Class မှ​သာ အမွေ​ဆက်ခံ​နိုင်​ခြင်း ဖြစ်​၏။ အဲ့​ဒီ​အတွက် ရှိ​သင့်​တဲ့ လုပ်ဆောင်​ချက်​များ​ကို အများ​အပြား​အသုံးပြု​လို​ပါ​က အစ​ကတည်းက Super Class တွင် ကြို​ရေးထား​ဖို့​လို​အပ်​ပေ​မည်။ တ​ဖန် ရှိ​တဲ့ ရှိ​သင့်​တဲ့​လုပ်ဆောင်​ချက်​များ​ထဲ​မှ တချို့​တစ်ဝက်​ကို​သာ အသုံးပြု​လို​သည့်​အခါ​မှာ​လည်း ဒုက္ခ​များ​တက်​ပေ​သည်။

ထို​အခါ​မျိုး​တွင် အသုံးဝင်​သည်မှာ Interface ဖြစ်​ပေ​သည်။ Polymorphism ကို​လည်း ပုံဖော်​ပေး​ရင်း၊ တစ်​ခု​တည်း​သော Class မှ အမွေ​ဆက်ခံ​နိုင်​ခြင်း ပြဿနာ​ကို​လည်း​ဖြေ​ရှင်း​ပေး​နိုင်​ပါ​သည်။လို​အပ်​သော လုပ်ဆောင်​ချက်​များ​ကို ဖြည့်​စွက်​လို​ပါ​က interface များ​ကို အကြိမ်ကြိမ် ဖြည့်​စွက်​ခြင်း​အား​ဖြင့် အသေး​စိတ် Class ဒီ​ဇိုင်း​များ​ကို ပုံဖော်​နိုင်​မှာ​ဖြစ်​ပါ​တယ်။

Poly3.java

public class Poly3 {

    static abstract class Cat {
        public abstract void getVoice ();
    }

    static interface Pet {
        public void getOwner();
    }

    static class NyoKyee extends Cat implements Pet {
        @Override 
        public void getVoice() {
            System.out.println("Meow");
        }

        @Override
        public void getOwner() {
            System.out.println("Owner is Maung Maung.");
        }
    }

    public static void main(String [] args) {
        NyoKyee myCat = new NyoKyee();
        myCat.getVoice();
        myCat.getOwner();
    }
}

ပြန်လည်​သုံးသပ်​ချက်

ကျွှန်တော်​တို့ ဤ​အခန်း​တွင် Polymorphism ဆို​တာ​ဘာ​လဲ။ ပြီး​တော့ Java ဘက်​က​ကြည့်​တဲ့ Polymorphism ဆို​တာ​ဘာ​လဲ။ Polymorphism ရဲ့ အကျိုး​သက်ရောက်​မှု့​တွေ မှာ​ဘာ​တွေ​ရှိ​သလဲ။ Java နဲ့ Polymorphism ကို ဘယ်​လို​ပုံဖော်​နိုင်​သလဲ​ဆို​တာ​ကို အဓိက​ထား​၍ဖော်​ပြ​ခဲ့​သည်။

Polymorphism ဆို​သည်မှာ အမည်​တူ​လုပ်ဆောင်​ချက်​တွေ​ဖြင့်၊ မ​တူညီ​သော​ရလဒ်​များ​ကို ရ​ရှိ​စေ​ခြင်း​ဟု​အဓိပ္ပါယ်​ဖွင့်​နိုင်​ပါ​သည်။ ဤ​ကဲ့သို့ အမည်​တူ လုပ်ဆောင်​ချက်​များ​ကို အသုံးပြု​ခြင်း​အား​ဖြင့် မှတ်​ရ​လွယ်ကူ​စေ​ခြင်း၊ အမှား​နည်းပါး​စေ​ခြင်း အစ​ရှိ​တဲ့ အကျိုး​ကျေးဇူး​များ​အပြင်၊ လို​အပ်​တဲ့​လုပ်ဆောင်​ချက်​များ​ကို Super Class မှ အမွေ​ဆက်ခံ​ပြီး၊ ပြောင်း​ပြီး​ရေးသား​လို​တဲ့ လုပ်ဆောင်​ချက်​များ​ကို​သာ Override လုပ်​ခြင်း​အား​ဖြင့် Class အုပ်စု​များ​ကို ဖွဲ့​စည်း​နိုင်​ကြောင်း အစ​ရှိ​တဲ့ အကျိုး​ကျေးဇူး​များ​ကို ရ​ရှိ​စေ​နိုင်​ပါ​တယ်။

တ​ဖန် Java တွင် Polymorphism ကို ပုံဖော်​နိုင်​ရန် Overload, Override, Abstract Class and Method နဲ့ Interface များ​ကို အသုံးပြု​နိုင်​ကြောင်း ဖော်​ပြ​ခဲ့​၏။

ဘာသာ​ရပ်​တွေ၊ သဘော​တရား​တွေ၊ Framework တွေ နဲ့ နည်း​ပညာ​များ​သည် ကရိယာ​များ​သာ​ဖြစ်​ကြ​သည်။ အသုံးပြု​မည့်​သူ​မှာ ရေးသား​သူ​ကိုယ်တိုင်​ဖြစ်​သည်။ ကရိယာ​တွေ​ဘယ်လောက်​ကောင်း​ကောင်း အနှစ်သာရ​မ​ရှိ​လျှင် Application တစ်​ခု​ဟာ အသုံး​တည့်​မှာ​မဟုတ်​ပါ​ဘူး။ F1 ကား​ပြိုင်​ပွဲ​ကို ကြည့်​စေ​လို​ပါ​သည်။ အကောင်း​ဆုံး​စက်​တွေ​နဲ့ အမြင့်​မား​ဆုံး အမြန်​ကို ပြိုင်ဆိုင်​နေ​ကြ​သည်။ စက်​တွေ​ရဲ့ လုပ်ဆောင်​နိုင်​အား​သည် အဲ့​ဒီ​လောက်​မ​ကွာ​ကြ​ပါ။ ဒါ​ပေ​မယ့် ကား​မောင်း​သူ​ရဲ့ သ​ဘာ​နဲ့ အနိုင်​အရှုန်း​ဟာ စကားပြော​စေ​ပါ​တယ်။

အဲ့​ဒီ​အတွက် အသုံးပြု​သူ​တွေ​က​လည်း နည်း​ပညာ​တွေ​ကို ပိုင်နိုင်​အောင် လေ့​လာ​လေ့​ကျင့်​ထား​ဖို့​လို​အပ်​ပါ​တယ်။ နောက်​တစ်​ခု F1 မှာ​ပြိုင်​နေ​တဲ့ ကား​တွေ​ဟာ​လည်း သာမန်​လမ်း​တွေ​မှာ မောင်း​လို့​မလွယ်​နိုင်​ပါ​ဘူး။ အဲ့​ဒီ​လို​ပဲ Application တိုင်း​မှာ နာမည်ကြီး Framework တွေ၊ နည်း​ပညာ​တွေ​နဲ့ ဖြစ်​ချင်​မှ​ဖြစ်​မှာ​ပါ။ ဘယ်​နေရာ​မှာ​ဘာ​ကို​သုံး​သင့်​တယ်​ဆို​တာ ဘာ​တွေ​က​ဘယ်​လို​ရှိ​တယ်​ဆို​တာ​ကို မ​သိ​ပဲ​နဲ့ မ​ဆုံးဖြတ်​နိုင်​ဘူး​လို့​ထင်​ပါ​တယ်။

အဲ့​ဒီ​အတွက် ဒီ​အိုင်​တီ​လောက​ထဲ​ကို ဝင်​ချင့်​တဲ့ လူ​ငယ်​များ​ကို အကြံပေး​ပါ​ဟု​ဆို​လျှင်၊ စာ​ဖတ်​အား​ကောင်း​ပါ​စေ လို့​ပြော​ချင်​ပါ​သည်။ များ⁠များ​ဖက်၊ များ⁠များ​လေ့​လာ​ပြီး အကောင်း​ဆုံး Code များ​ကို​ရေ​သားရင်း ပီ​တိ​ဝေ​နိုင်​ကြ​ပါ​စေ။

Override ဆို​သည်မှာ

Override ကို လွယ်⁠လွယ်​နှင့် ရှင်း​ပြ​ရ​မည်​ဆို​လျှင် Super Class တွင်​ရေးသား​ထား​သော လုပ်ဆောင်​ချက်​နှင့် ထပ်တူ လုပ်ဆောင်​ချက်​ကို Sub Class တွင်​ရေးသား​ခြင်း​အား​ဖြင့် Super Class ၏ လုပ်ဆောင်​ချက်​ကို​ဖုန်း​ကွယ်​ခြင်း​ဟု အဓိပ္ပါယ်​ရ​ပါ​လိမ့်​မည်။ ဖုန်း​ကွယ်​ခြင်း။ ဘာ​လို့​ဖုန်း​ကွယ်​ရ​တာ​လဲ။ ဖုန်း​ကွယ်​လို့ ဘာ​အကျိုး​ရှိ​မှာ​လဲ ဟု​စဉ်းစား​စရာ​ရှိ​ပါ​လိမ့်​မည်။ ကျွှန်တော်​တို့ လက်​တွေ​ရေး​ပြီး​လေ့​လာ​ကြည့်​ကြ​ပါ​စို့။

ကျွှန်တော်​တို့ SuperClass တစ်​ခု​ရယ်၊ အဲ့​ဒီ SuperClass ရဲ့ အမွေ​ဆက်ခံ​မယ့် SubClass တစ်​ခု ကို​ရေး​ပါ​မယ်။ ပြီး​တော့ သူ​တို့​တွေ​မှာ doBusiness() ဆို​တဲ့ လုပ်ဆောင်​ချက်​ကို အသီး​သီး​ရေးထား​ပါ​မယ်။ ပြီး​တော့ MainClass ထဲ​က​နေ SuperClass ရဲ့ instance ကို SubClass နဲ့ new လုပ်​ပြီး ခေါ်​ယူ​ပါ​မယ်။ ပြီး​တော့ အဲ့​ဒီ instance ရဲ့ doBusiness() ကို ခေါ်​ကြည့်​တဲ့ အခါ​မှာ ဘယ် class ရဲ့ လုပ်ဆောင်​ချက်​ကို ခေါ်​ယူ​အသုံးပြု​နေ​သလဲ ဆို​တာ​ကို လေ့​လာ​ကြည့်​ကြ​ရအောင်။

class SuperClass {
    public void doBusiness() {
        System.out.print("This is from SuperClass.");
    }
}

class SubClass extends SuperClass {
    public void doBusiness() {
        System.out.print("This is from SubClass.");
    }
}
public class Main {
    public static void main(String [] args) {
         SuperClass instance = new SubClass();
         instance.doBusiness();
    }
}

ကျွှန်တော်​တို့ အထက်​ပါ Src Code တွေ​ကို Text Editor တစ်​ခု​ကို အသုံးပြု​၍ ရေးသား​ပြီး၊ Main.java ဆို​ပြီး သိမ်းဆည်း​ထား​ပါ​မယ်။ ပြီး​ရင်​ကွန်​ပိုင်း​လုပ်​ပြီး အလုပ်​လုပ်​ခိုင်း​ကြည့်​ပါ​မယ်။ ပတ်ဝန်းကျင်​ပြင်ဆင်​မှု့​နဲ့​ပတ်သက်​လို့​ကတော့ ယခင် ကျွှန်တော်​ရေးသား​ခဲ့​သော Java SE 7 : Hello Java 7! မှ လေ့​လာ​နိုင်​ပါ​သည်။ လက်​ရှိ JDK 7 ဟာ beta version ဖြစ်​တဲ့​အတွက် လက်​ရှိ stable version ကို ပြောင်း​သုံး စေ​လို​ပါ​တယ်။

အထက်​ပါ Main Class ရဲ့​ရလဒ်​ကို လေ့​လာ​ကြည့်​ကြ​ရအောင်။ This is from SubClass. ဆို​တာ​ကို ဖော်​ပြ​နေ​တာ​ကို​တွေ့​ရ​ပါ​လိမ့်​မယ်။ ကျွှန်တော်​တို့ Main Class ထဲ​မှာ SuperClass ရဲ့ instance ကို ခေါ်​ပြီး doBusiness လုပ်ဆောင်​ချက်​ကို လုပ်ကိုင်​ခဲ့​စေ​ပေ​မယ့်၊ လက်တွေ့ new လုပ်​နေ​တာ​က SubClass ဖြစ်​ပြီး၊ ပုံစံ​တူ doBusiness လုပ်ဆောင်​ချက်​ကို ထပ်မံ​ရေးသား​ခြင်း​အား​ဖြင့် လက်​ရှိ​အလုပ်​လုပ်​သော​အခါ SubClass ရဲ့ လုပ်ဆောင်​ချက်​ကို လုပ်ဆောင်​သွား​တာ​ကို သိမြင်​နိုင်​ပါ​တယ်။ ဒီ​လို override ရဲ့ ထူးခြား​ချက်​ကို အသုံးပြု​နေ​တာ​ကတော့ OOP ရဲ့​အနှစ်သာရ​တစ်​ခု​ဖြစ်​တဲ့ Polymorphism မှာ​ပါ​ပဲ။ Polymorphism ရဲ့ အကြောင်း​ကို နောက်​အပါတ်​မှာ ဆက်​လက်ဖော်​ပြ​သွား​ပါ​ဦး​မယ်။

Override နဲ့ Overload

Overload ကို အသုံးပြု​ခြင်း​အား​ဖြင့်၊ class တစ်​ခု​အတွင်း​မှာ Arguments တွေ​မ​တူ​ပဲ အမည်​တူ လုပ်ဆောင်​ချက် တွေ​ကို​ရေးသား​ချင်း​အား​ဖြင့် လုပ်ဆောင်​ချက်​တွေ​ရဲ့ ဦးတည်​ချက်​တွေ​ကို နားလည်​လွယ်​အောင် ရေးသား​အသုံးပြု​နိုင်​ပါ​တယ်။
Override ကို​အသုံးပြု​ခြင်း​အား​ဖြင့်၊ အမျိုး​အစား​တူ​ပြီး လုပ်ဆောင်​ချက်​တွေ​မ​တူ​တဲ့ Class Design တွေ​ကို ရေးသား​နိုင်​ပါ​တယ်။

Overload ကို လေ့လာခြင်း

Java ကို​လေ့​လာ​စ​သူ​များ​သည် Override နှင့် Overload ကို မ​ကွဲပြား​ကြ​သည်​က များ​သည်။ ကျွှန်တော်​လည်း​ဤ​ကဲ့သို့​ပင် နာမည်​တွေ​က​လည်း ခပ်​ဆင်⁠ဆင်​ဖြစ်​နေ​ပြန်၊ ပြီး​တော့​လည်း စာ​သင်​ခန်း​ထဲ​တွင် တစ်​ခါ​လောက်​သာ​ပါ​ပြီး နောက်ထပ်​ပြန်​မပေါ်​လာ​တော့​ပြန်​ပါ​သ​ဖြင့်၊ သိ​သ​လိုလို​နှင့် ရော​နေ​တတ်​သည်​က​များ​သည်။

ကျွှန်တော်​တို့​သည် ဘယ်​လို​သဘော​တရား​ရှိ​သည်​ဆို​သည်​ကို သာ​လေ့​လာ​ခဲ့​ပြီး ဘယ်​လို​အသုံးပြု​ရ​သည်​ဆို​သည်​ကို မ​လေ့​လာ​ခဲ့​ကြ​၍​ဖြစ်​သည်။ ကျွှန်တော်​တို့ သည်​အခန်း​တွင် ဘယ်​လို​အသုံးပြု​သင့်​သည်​ကို အဓိက​ထား​၍​လေ့​လာ​သွား​ပါ​မည်။ Override နဲ့ Overload ကို ကွဲပြား​စေ​ရန် OOP နဲ့ မ​ပတ်သက်​ပေ​မယ့် ဤ​အခန်း​တွင် Overload အကြောင်း​ကို ဖော်​ပြ​သွား​ပါ​မည်။

Overload ဆိုသည်မှာ Class တစ်​ခု​အတွင်း​တွင် အမည်​တူ Methods များ​ကို ရေးသား​ချင်း​ဟု​အဓိပ္ပါယ်​ရ​ပါ​သည်။ Class တစ်​ခု​အတွင်း​တွင် Parameter ကွဲပြား​ပေး​မည့် လုပ်ဆောင်​ချက်​များ​သည် တူညီ​ကြောင်း​ကို သိသာ​စေ​ရန် Overload ကို အသုံးပြု​ရေးသား​လေ့​ရှိ​ပါ​သည်။ Utility Class များ​ကို ရေးသား​ရာ​တွင် ရေးသား​လေ့​ရှိ​ပါ​သည်။

public class ConnectionUtil {

      public static HttpURLConnection getPostConnection(String url,
                      List<HttpCookies> cks, Map<String, String> params, String enc)
                      throws IOException {

         HttpURLConnection conn = getConnection(url, cks);
         conn.setDoOutput(true);
         PrintStream ps = new PrintStream(conn.getOutputStream());

         ps.print(getParamStringFromMap(params, enc));
         ps.flush();
         ps.close();

         conn.getContent();
         return conn;
       }

     public static HttpURLConnection getPostConnection(String url,
                      List<HttpCookies>  cks, Map<String, String> params)
                  throws IOException {

          HttpURLConnection conn = getConnection(url, cks);
          conn.setDoOutput(true);
          PrintStream ps = new PrintStream(conn.getOutputStream());

          ps.print(getParamStringFromMap(params));
          ps.flush();
          ps.close();

          conn.getContent();
          return conn;
       }


        public static Document parse(HttpURLConnection conn) throws SAXException,
                  IOException {

           DOMParser parser = new DOMParser();
           parser.parse(new InputSource(conn.getInputStream()));
           DOMReader dr = new DOMReader();
           return dr.read(parser.getDocument());
      }
}

အထက်​ပါ ConnectionUtil Class သည် HttpUrlConnection တွေ​ကို အလွယ်​တ​ကူ ရ​ယူ​နိုင်​ရန်​အတွက် ရေးသား​ထား​သော Utility Class တစ်​ခု​ဖြစ်​ပါ​တယ်။ သည် Class ထဲ​တွင်​သတိထား​စေ​ချင်​တာ​က HttpUrlConnection ကို ရ​ယူ​နိုင်​ရန် getPostConnection ဆို​တဲ့ အသုံးပြု​ချက်​ကို ၂ ခု​ခွဲ​ရေးထား​တာ​ကို တွေ့​မြင်​ရ​ပါ​လိမ့်​မယ်။ လုပ်ဆောင်​ချက် (Method)အမည် ကို​ကြည့်​ရုံ​နှင့် Post Type Connection ကို​ရ​နိုင်​တဲ့ လုပ်ဆောင်​ချက်​တွေ​ဆို​တာ မြင်​ရုံ​နှင့်​သိသာ​နိုင်​ပါ​တယ်။
ပဋ္ဌ​မ လုပ်ဆောင်​ချက်​ကို ကြည့်​ရအောင်။ သူ့​မှာ HttpUrlConnection ကို ရ​ယူ​ရန်​အတွက် အောက်​ပါ Parameter တွေ​ကို လက်ခံ​ရ​ယူ​နေ​ပါ​တယ်။

• String url : ဆက်​သွယ်​လို​သည့် URL လိပ်စာ စာ​ကြောင်း
• List cks : Login လုပ်​ပြီး​မှ ဆက်​သွယ်​ရ​သည့် ဆိုက်​များ​အတွက် မှတ်ထား​သည့် HttpCookiesများ
• Map params : Post လုပ်​မည့် Parameter စာသား​များ
• String enc : Encoding စာ အမျိုး​အစား

လုပ်ဆောင်​ချက်​ထဲ​တွင် အထက်​ပါ Parameterများ​ဖြင့် HTTP Request ကို Post လုပ်​ပြီး​သား HttpUrlConnection ကို ပြန်​ရ​ယူ​နေ​စေ​ပါ​တယ်။

ဒုတိယ​လုပ်ဆောင်​ချက်​ကို ကြည့်​ရအောင်။ သူ​လည်း​ပဲ အထက်​ပါ Parameter များ​ထဲ​မှ Encoding စာ​အမျိုး​အစား​မှ​လွဲ တဲ့ Parameter တွေ​ကို ရ​ယူ​ပြီး HttpUrlConnection ကို ပြန်​ပေး​နေ​ပါ​တယ်။ Encoding စာသား​မ​ပါ​တာ​က​လွဲ​ရင် လုပ်ဆောင်​ချက်​တွေ​က အတူတူ​ဖြစ်​ပါ​တယ်။ Encoding စာသား​ကို သိ​ပြီး Post Type Connection ကို ရ​ယူ​လို​လျင် ပဋ္ဌ​မ လုပ်ဆောင်​ချက်​ကို အသုံးပြု​ပြီး၊ Encoding စာသား​ကို​မ​သိ​ပါ​က ဒုတိယ လုပ်ဆောင်​ချက်​ကို အသုံးပြု​သင့်​သည် ဆို​သည်​ကို သိသာ​စေ​နိုင်​ပါ​သည်။

ဤ​ကဲ့သို့ Class တစ်​ခု​အတွင်း​တွင် အမည်​တူ​ပြီး၊ Parameter အမျိုး​အစား၊ အရေအတွက် မ​တူ​တဲ့ လုပ်ဆောင်​ချက်​များ​ကို ထပ်ခါထပ်ခါ ရေးသား​ချင်း​ကို Overload ဟုခေါ်​ပါ​သည်။ နောက်​အခန်း​များ​တွင် Override နှင့် Polymorphism အကြောင်း​ကို ဆက်လက်​ရေးသား​သွား​ပါ​ဦး​မည်။

မျိုးရိုးဆက်ခံမှု့နှင့် သတိထား​ရန်​အချက်​များ

မျိုးရိုးဆက်ခံမှု့ (Inheritance) အကြောင်း​ကို လေ့​လာ​ရာ​တွင်၊ မျိုး​ရိုး​ဆက်ခံ​စေသော Super Class နှင့် မျိုး​ရိုး​ဆက်ခံ​သော Sub Class တွေ​က ဘယ်​လို​ဖြစ်ပေါ်​လာ​တယ် ဆို​တာ​ကို လေ့​လာ​ကြည့်​မည် ဆို​လျှင် နားလည်​ရ​လွယ်ကူ လိမ့်​မည်။

မျိုး​ရိုး​ဆက်ခံ​မှု့​ရဲ့ အဓိက ရည်​ရွယ်​ချက်​သည် Super Class ရဲ့ ပိုင်ဆိုင်​မှု့​တွေ​ကို၊ အခြား​သော Class များ​မှ တ​ဆင့်​ပြန်​လို​အသုံးပြု လို​ခြင်း ဖြစ်​၏။ အောက်​ပါ Source Code ကို ကြည့်​ပါ။ SuperClass တွင် တန်ဖိုး 10 ရှိ​တဲ့ price ဆို​တဲ့ အချက်အလက်​နှင့် showPrice() ဆို​တဲ့ လုပ်ဆောင်​ချက်​ကို ပိုင်ဆိုင် ပါ​တယ်။ SubClass မှာ​တော့ Constructor သာ​ပိုင်ဆိုင်​ပြီး extends SuperClass ဆို​ပြီး SuperClass ရဲ့ အမွေ​ဆက်ခံ​မှု့​ကို ရ​ယူ​နေ​ပါ​တယ်။ တ​ဖန် Constructor ထဲ​တွင် price ၏ တန်ဖိုး​ကို 20 အဖြစ် အစားထိုး​နေ​၏။

SuperTest Class ထဲ​မှ main ထဲ​တွင် SubClass ရဲ့ instance ကို ခေါ်​ယူ​ပြီး showPrice() လုပ်ဆောင်​ချက်​ကို လုပ်ဆောင်​စေ​ပါ​တယ်။ အောက်​ပါ Source Code များ​ကို ကွန်​ပိုင်း​လုပ်​ပြီး Run ကြည့်​မည်​ဆို​ပါ​က The Price is 20 ဟု ကွန်​ဆိုး​တွင် ဖော်​ပြ​ပါ​လိမ့်​မည်။ ဤ​အချက် တစ်​ခု​တည်း​ကို​သာ ကြည့်​မည်​ဆို​ပါ​က SubClass ထဲ​မှ SuperClass ၏ အချက်အလက်​တွေ၊ လုပ်ဆောင်​ချက်​တွေ​ကို ဆက်​သွယ် အသုံး​ချ​နိုင် သ​လို​မြင်​နိုင် ပေ​လိမ့်​မည်။

package test;

class SuperClass {
    int price = 10;
    void showPrice() {
         System.out.println("The Price is " + price);
    }
}
class SubClass extends SuperClass{
    public SubClass() {
        price = 20;
    }
}
public class SuperTest {
   public static void main(String [] args) throws InstantiationException, IllegalAccessException {
        SubClass sub = SubClass.class.newInstance();
        sub.showPrice();
   }
}

တကယ်​ပဲ SuperClass ရဲ့ ပိုင်ဆိုင်​မှု့​တွေ​ကို SubClass မှ တိုက်ရိုက် အသုံးပြု​နိုင်​သလား ဆို​တာ​ကို ပို​သိ​ရအောင် ကျွှန်တော်​တို့ Source Code တွေ​ကို နည်း⁠နည်း​ပြင်​ကြည့်​ကြည့် ကြ​ရအောင်။

class SuperClass {
    int price;
    public SuperClass(int i) {
        price = i;
    }
    void showPrice() {
         System.out.println("The Price is " + price);
    }
}

အထက်​ပါ အတိုင်း SuperClass ကို ပြုပြင်​ပြီး Source Code များ​ကို ကွန်​ပိုင်း​လုပ်​ကြည့်​မည် ဆို​ပါ​က Compile Error ထွက်ပေါ်​မည် ဖြစ်​၏။ အဘယ်​ကြောင့်​ဆိုသော် SubClass ထဲ​တွင် SuperClass ရဲ့ Constructor ဖြစ်​တဲ့ SuperClass(int i) ကို မ​ရေးသား​ထား​သော​ကြောင့် ဖြစ်​သည်။ တ​နည်း​ဆို​ရသော် Memory ပေါ်​တွင် SubClass ကိုခေါ်​ယူ အသုံး​ချ​ရာ​တွင် နောက်​ကွယ်​တွင် SuperClass ကိုခေါ်​ယူ​ပြီး အသုံး​ချ​နေ​သော​ကြောင့် ဖြစ်​၏။ ကွန်​ပိုင်​လာ​မှ SuperClass ရဲ့ Instance ကို ခေါ်​ယူ​ဖို့​အတွက် Constructor ကို ခေါ်​ယူ​ရာ​တွင် int i ကို ရှာ​မ​တွေ့​ပါ​သ​ဖြင့် Error အဖြစ် ဖော်​ပြ​ခြင်း​ဖြစ်​ပါ​သည်။

အထက်​ပါ အချက်​ကို ကြည့်​ခြင်း​အား​ဖြင့် SuperClass ကို ပြောင်း​လည်း​မည်​ဆို​ပါ​က SubClass အပေါ်​တွင် တိုက်ရိုက် အကျိုး​သက်ရောက်​မှု့ များ​ရှိ​သည်​ဆို​သည်​ကို သိမြင်​နိုင်​ပေ​သည်။ အမွေ​ဆက်ခံ​မှု့​သည် Class တစ်​ခု​နှင့် တစ်​ခု​ကို ချုပ်​နှောင်​မှု့​တွေ​ကို ဖြစ်ပေါ်​စေ​သည် ဆို​သည့်​အချက်​သည် သတိထား​စရာ အချက်​ဖြစ်​၏။
အောက်​ပါ​အတိုင်း SubClass ကို ပြုပြင်​ရေးသား​မည် ဆို​ပါ​က ကွန်​ပိုင်း Error ထွက်ပေါ်​မည် မဟုတ်​တော့​ပေ။

class SubClass extends SuperClass{
    public SubClass() {
        super(20);
    }
}

မျိုးရိုးဆက်ခံမှု့ ဆို​တာ​ဘာ​လဲ ဆို​တာ​ကို ပြန်​စဉ်းစား​ကြည့်​ကြ​ရအောင်။ မျိုး​ရိုး​ဆက်ခံ​မှု့​ကို အသုံးပြု​ခြင်း​အား​ဖြင့် သားသမီး instance ကို ခေါ်​ယူ​ရာ​၌၊ နောက်​ကွယ်​တွင် မိဘ instance ကို အလို​အလျှောက် ခေါ်​ယူ​ပြီး၊ သားသမီး instance မှ​တ​ဆင့် မိဘ​၏​ပိုင်ဆိုင်​မှု့​များ​ကို အမည်ခေါ်​စရာ​မ​လို​ပဲ အသုံး​ချ​နိုင်​ပေ​သည်။ သို့ရာတွင် Class တစ်​ခု​နှင့်​တစ်​ခု​၏ ချုပ်​နှောင်​မှု့​များ​လည်း ပေါ်ပေါက်​စေ​မည် ဖြစ်​၏။

Class တစ်​ခု​၏ ပိုင်ဆိုင်​မှု့​များ​ကို ပြန်လည်​အသုံး​ချ​လို​မှု့ တစ်​ခု​တည်း​မှ​တွေး​မည် ဆို​လျှင် အသုံးပြု​လို​သည့် Class ရဲ့ instance ကို ခေါ်​ယူ အသုံးပြု​မည် ဆို​ပါ​က ရ​ရှိ​နိုင်​၏။ မျိုး​ရိုး​ဆက်ခံ​မှု့​ကို အသုံးပြု​ခြင်း​၏ အကျိုး​ကျေးဇူး ကို​ပြ​ပါ​ဆို​ပါ​က မိဘ Class ရဲ့ instance ကို အလို​အလျှောက် ခေါ်​ယူ​နိုင်​ခြင်း၊ မိဘ instance ရဲ့ ပိုင်ဆိုင်​မှု့​တွေ​ကို အမည်တပ်​စရာ​မ​လို​ပဲ အသုံးပြု​နိုင်​ခြင်း တို့​သာ​ရှိ​မည်​ဟု မြင်​ပေ​မည်။

ယခု​အထိ ရှင်း​ပြ​ချက်​များ​ကို ကြည့်​မည်​ဆို​ပါ​က မျိုး​ရိုး​ဆက်ခံ​မှု့​ကို အသုံးပြု​လောက်​တဲ့ အကျိုး​သက်ရောက်​မှု့ ရှိ​ပါ့​မ​လား​ဟု မေး​စရာ​ရှိ​ပါ​လိမ့်​မည်။ မဟုတ်​ပါ။ Java တွင် Override ၊ Polymorphism အစ​ရှိ​တဲ့ အတွေး​အခေါ်​များ​သည် မျိုး​ရိုး​ဆက်ခံ​မှု့​ကို အခြေ​ခံထား​သော အသုံးပြု​ချက်​များ ဖြစ်​ကြ​၏။ နောက်​အခန်း​များ​တွင် ဆက်လက်​ပြီး​လေ့​လာ သွား​ပါ​မည်။
ဤ​အခန်း​တွင် ဖော်​ပြ​လို​သည်မှာ မျိုး​ရိုး​ဆက်ခံ​မှု့​ကို Class များ​၏ အဖွဲ့​အစည်း​များ​ကို တည်ဆောက်​ရာ၊ Class တစ်​ခု​နှင့် တစ်​ခု​၏ ပတ်သက်​မှု့​တို့​ကို သတ်​မှတ်​ရာ တွင် အသုံးပြု​စေ​လို​ပါ​သည်။ သို့မဟုတ်​ပဲ Class တစ်​ခု​၏ ပိုင်ဆိုင်​မှု့ ကို ပြန်လည်​အသုံးပြု​လို​မှု့ တစ်​ခု​တည်း​ကြောင့် ပတ်သက်​မှု့​မ​ရှိ​သော Class တစ်​ခု​မှ မျိုး​ရိုး​ဆက်ခံ​မှု့​ကို အသုံးပြု​မည်​ဆို​ပါ​က မ​လို​အပ်​သော ချုပ်​နှောင်​မှု့​များ​ကို ဖြစ်ပေါ်​စေ​ပါ​သ​ဖြင့် အထူး​သတိထား စေ​လို​ပါ​သည်။

Java နှင့် Object Oriented သဘော​တရား​

Java Programming ကို လေ့​လာ​ရာ​တွင် လေ့​လာ​သူ​တစ်​ဦး​အနေ​နှင့် ရင်ဆိုင်​ရ​မည့် ပြဿနာ များ​ထဲ​တွင် Object Oriented သည်​လည်း အဓိက အခန်း​မှ ပါဝင်​နေ​၏။ Object Oriented နှင့်​ပတ်သက်​သော ဘာသာ​ရပ်​များ၊ စာအုပ်​များ၊ ရှင်းလင်း​ချက်​များ များ​စွာ​ရှိ​ကြ​ပါ​၏။ သို့ရာတွင် Object Oriented သည် နားလည်​ရ​ခက်​သည်​ဟု ပြော​နေ​သူ အများ​အပြား​ရှိ​နေ​ဆဲ​ပင်။ အချို့​သော​သူ​များ​သည် Object Oriented ကို နားလည်​သည်​ဟု ပြော​ကြ​၏။ ဒါ​ဆို​ရင် Polymorphism ကို​နားလည်​ပြီး Coding တွေ​မှာ အသုံးပြု​နေ​သလား​ဟု မေး​ပါ​က အဖြေ​ခက်​နေ​တတ်​၏။

သို့ရာတွင် အံ့​သြ​စရာ ကောင်း​လောက်​အောင်​ပင် Object Oriented ကို ခက်ခဲ​လှ​ပါ​သည်​ဟု ပြော​နေ​ကြ​ပေ​မယ့် Inheritance ကို သိ​လား​လို့​မေး​လျှင် မှန်ကန်စွာ နားလည်​ထား တတ်​ကြ​၏။ ဒါ​ဆို​လျှင် ဘာ​လို့ Object Oriented ကို ခက်​တယ်​လို့ ထင်​နေ​ရ​တာ​လဲ။

အဲ့​ဒီ အဖြေ​ဟာ နောက်ထပ်​မေး​မည့် မေးခွန်း​၏ နောက်​ကွယ်​တွင် တည်​ရှိ​လိမ့်​မည် ဟု​ထင်​ပါ​သည်။ Inheritance ကို အသုံးပြု​ခြင်း​၏ ကောင်းကျိုး၊ ဆိုး​ကျိုး​တွေ​ကို သိ​လား​ဟု​မေး​ပါ​မည်။ အတော်​များ⁠များ​က Inheritance မှာ ဆိုး​ကျိုး​တွေ ရှိ​လို့​လား​ဟု ပြန်​မေး​ကြ​မည်။ အဲ့​ဒီ​နေရာ​မှာ ပြဿနာ​က စ​ပါ​တော့​သည်။ Object Oriented ကို နား​မ​လည်​စေသော အခြေ​ခံ​သည် ဤ​နေရာ​မှ စတင်​ပါ​တော့​သည်။

Object Oriented ၏ သဘော​တရား​သည် လွန်စွာ​ကောင်းမွန်​သည်မှာ မှန်​၏။ သို့ရာတွင် Java Program တစ်​ခု​မှ Object Oriented ကို အသုံးပြု​ရာ​တွင် အသုံးပြု​ပုံ မှားယွင်း​ခဲ့​ပါ​က လုံး​ဝ အသုံး​မ​ဝင်​သော Code များ​ကို ရေး​မိ​သွား​နိုင်​သည် အထိ အန္တ​ရယ်​ရှိ​ပါ​သည်။

ကျွှန်တော်​တို့ OOP ဖြစ်​ရင်​ပြီး​ရော ဆို​ပြီး မှားယွင်း​သော အသုံး​ချ​မှု့​များ​မှ ကင်း​ဝေး​စေ​ရန်၊ Object Oriented ရဲ့ အဓိက​ကျ​သော Encapsulation, Inheritance, Polymorphism အစ​ရှိ​တဲ့ အခြေ​ခံ သဘော​တရား​များ​မှ စ​ပြီး ပြန်လည်​လေ့​လာ​သွား​မည် ဖြစ်​သည်။

Encapsulation ကို အသုံးပြု​ပါ

Encapsulation သည် OOP ရဲ့ အခြေ​ခံ​ကျ​တဲ့ အတွေး​အခေါ်​တစ်​ခု​ဖြစ်​၏။ Encapsulation က ဘာ​လို့​လို​အပ်​တာ​လဲ ဆို​တာ​ကို မ​စဉ်းစား​ခင် OOPရဲ့ သမိုင်း​ကို ပြန်​ကြည့်⁠ကြည့်​ကြ​ရအောင်။ Software Engineering လောက​မှာ OOP က စတင်​နေရာ ရ​လာ​ခဲ့​တာ​ကတော့ လွန်​ခဲ့​တဲ့ နှစ်​၂​၀​ခန့်​က​ဖြစ်​၏။ ကမ္ဘာ​တ​ဝှမ်း​၌ IT နည်း​ပညာ​ကို စီးပွား​ရေး​အခြေ​ခံ တွေ​မှာ၊ လူ​နေ​မှု့​စနစ်​ရဲ့ အခြေ​ခံ​တွေ​မှာ ရင်းနှီး​မြှုပ်​နှံ​မှု့​တွေ​ကို အပြိုင်​အဆိုင် ပြုလုပ်​နေ​တဲ့ ကာလ​ဖြစ်​ခဲ့​၏။ ထို​ခေတ်​သည် System လို​အပ်​မှု့​များ​နှင့် စာ​လျှင် IT Engineerရဲ့ အရေအတွက်​ဟာ အလွန်​နည်းပါး ခဲ့​သော ကာလ​လည်း​ဖြစ်​၏။

အသစ်အသစ်တွေကို ပြန်​ရေး နေ​သည်​နှင့်​စာ​လျှင် ရေးထား​ပြီး​သား System တွေ​ကို ဘယ်​လို​ပြန် အသုံး​ချ​နိုင်​အောင် လုပ်​မ​လဲဆို​တာ IT သမား​တွေ အတွက် မ​ရှိ​မ​ဖြစ်​လို​အပ်ခဲ့​တဲ့ လို​အပ်​ချက်​တစ်​ခု ဖြစ်​ခဲ့​၏။ Software ရဲ့ အစိတ်​အပိုင်း​တွေ​ကို ရုပ်​ပစ္စည်း အဖြစ်​ကြည့်​မြင်​ပြီး၊ အစိတ်​အပိုင်း​တွေ​ကို စုပေါင်း​အသုံး​ချ​ခြင်း အား​ဖြင့် System တစ်​ခု​ကို တည်ဆောက်​သော OOP ရဲ့ တွေးခေါ်​မှု့​တွေ​ဟာ ရေး​ပြီး​သား Software တွေ​ကို ပြန်လည်​အသုံး​ချ​လို​တဲ့ အဲ့​ဒီ​ခေတ်​ရဲ့ လို​အပ်​ချက်​နှင့် ကိုက်​ညီ​နေ​ခဲ့​၏။
ထို့​ကြောင့် OOP ကို အခြေ​ခံ​တဲ့ Programming ဘာသာ​ရပ်​တွေ အများ​အပြား ထွက်ပေါ်​လာ​ရ​ခြင်း ဖြစ်​သည်။ ကျွှန်တော်​တို့ OOP ကို ဘာ​လို့​အသုံးပြု​ခဲ့​ကြ​တယ် ဆို​တာ​ကို​သဘောပေါက်​ပြီး​ရင် Encapsulation ဘက်​ကို ပြန်​စဉ်းစား​ကြည့်​ကြ​ရအောင်။

Encapsulation ဆို​သည်မှာ လုံခြုံ​အောင် ထုတ်​သိမ်းထား​ခြင်း​ဟု အဓိပ္ပါယ် ရ​ပါ​သည်။ ဘာ​ကြောင့် Encapsulation လုပ်​ဖို့​လို​တာ​လဲ​ဟု စဉ်းစား​လျှင် OOP ရဲ့ လို​အပ်​ချက်​တွင် အဖြေ​ရှိ​ပါ​သည်။ ရေးသား​ထား​သော Object တစ်​ခု​ကို ရေးသား​သူ တစ်​ယောက်​တည်း​က အသုံးပြု​မည် မဟုတ်။ ထို့​အပြင် ရေးသား​ပြီး အချိန် အတန်​ကြာ​မှ ပြန်လည်​အသုံး​ချ​သည့်​အခါ​လည်း ရှိ​ပါ​လိမ့်​မည်။ Object ၏ အချက်အလက်​တွေ​နဲ့ လုပ်ဆောင်​ချက်​တွေ​ကို အခြား​သော နေရာ​များ​မှ နှစ်သက်​သ​လို အသုံးပြု​ကြ​မည် ဆို​လျှင် ခက်​ပေ​မည်။ အဲ့​ဒီ​အတွက် Object တစ်​ခု​က ပိုင်ဆိုင်​တဲ့ အချက်အလက်​နဲ့ လုပ်ဆောင်​ချက်​တွေ​ကို ပြင်​ပ​မှ မ​မြင်​နိုင်​ရန် ဖုံးကွယ်​ထား​ဖို့ လို​အပ်​ပေ​သည်။ ဤ​ကဲ့သို့ ဖုံးကွယ်​ခြင်း​ကို Encapsulation ဟုခေါ်​၏။

ကျွှန်တော်​တို့ Java မှာ Encapsulation ကို ဘယ်​လို​လုပ်​လဲ ဆို​တာ​ကို လက်တွေ့ Code တွေ​ရေး​ကြည့်​ကြ​ရအောင်။ အောက်​ပါ User.java ကို ကြည့်​ပါ။ Encapsulation ကို အသုံး​မ​ပြု​ပဲ ရေးသား​ထား​ခြင်း ဖြစ်​သည်။

public class User {

        public String name;
        public int age;

        public User(String name, int age) {
                this.name = name;
                this.age = age;
        }
} 

အထက်​ပါ User Class ၏ အချက်အလက်​များ ဖြစ်​ကြ​သော name, age နှင့် Constructor ဖြစ်​သော User(String name, int age) သည် public များ​ဖြစ်​ကြ​၍ OOP ၏​အမြင်​မှ​ဆို​လျှင် လုံခြုံ​မှု့​မ​ရှိ​ဟု သတ်​မှတ်​နိုင်​သည်။ ဟုတ်​ပြီ၊ လုံခြုံ​မှု့​ရှိ​အောင် Encapsulation လုပ်​ကြ​စို့။ အောက်​ပါ Src Code များ​သည် public ကို private အဖြစ်​ပြောင်း​လည်း​ပြီး Encapsulation လုပ်​ထား​သော Code များ​ဖြစ်​၏။

public class User {

        private String name;
        private int age;

        private User(String name, int age) {
                this.name = name;
                this.age = age;
        }
} 

အထက်​ပါ​အတိုင်း Encapsulation သည် လွယ်ကူ​လှ​ပေ​သည်။ သို့ရာတွင် ဤ​အတိုင်း​ဆို​ပါ​က အသုံးဝင်​မည် မဟုတ်​ပေ။ Constructor က private ဖြစ်​နေ​ပါ​သ​ဖြင့် instance ကို လုပ်​ယူ​နိုင်​မည်​မဟုတ်။ ဤ​နေရာ​သည် ရွေးချယ်​ရန် အနည်းငယ် ခက်ခဲ ပေ​သည်။ package အတူတူ အတွင်း​မှာ​သုံး​မှာ​လား၊ ဒါ​ဆို​ရင် private ကို ဖြုတ်​လိုက်​ရုံ​ပင်။ ဒါ​မှ​မဟုတ် package အပြင်​က အထိ အသုံးပြု​စေ​လို​တာ​လား။ ဆုံးဖြတ်​ရန် အနည်းငယ် ခက်ခဲ​လှ​၏။ဦးစွာ ဤ​နေရာ​တွင် Constructor ကို public အဖြစ် ပြောင်း​လည်း​ပါ​မည်။ ဤသို့​ပြောင်း​လည်း​ခြင်း အား​ဖြင့် package ထဲ​မှာ​ရော အပြင်​မှာ​ပါ instance ကို လုပ်​ယူ​နိုင်​မည် ဖြစ်​၏။

သို့ရာတွင် အခြား​သော ပြဿနာ​လည်း ရှိ​ပါ​သေး​သည်။ ပိုင်ဆိုင်​သော အချက်အလက်​များ​ကို ပြောင်း​လည်း​၍ မ​ရ​နိုင်​ပေ။ age အချက်အလက်​သည် နှစ်​တိုင်း ပြောင်း​လည်း​နိုင်​ပါ​သ​ဖြင့် ပြင်​ပ​မှ ပြောင်း​လည်း​မ​ရ​နိုင်​ခြင်း​သည် သိပ်​မ​ကောင်း​လှ​ပေ။ public အဖြစ်​ပြောင်း​လည်း လိုက်​ပြန်​ရင်​လည်း မ​ဖြစ်​နိုင်​တဲ့ အသက်​တွေ (အနှုတ်​တန်ဖိုး) သတ်​မှတ်​သွား​နိုင်​သည်။ ဤ​နေရာ​တွင် Encapsulation ကို စောင့်​စည်း​ရင်း ပြင်​ပ​ကို​လည်း ပြုပြင်​နိုင်​အောင် မ​လုပ်​နိုင်​ဘူး​လား​ဟု စဉ်းစား​စရာ ဖြစ်လာ​သည်။ ဤ​ကဲ့သို့ အခြေအနေ​မျိုး​တွင် Access Method များ​သည် အသုံးဝင်​လှ​ပေ​သည်။

public void setAge(int age) {
        if(age > this.age) {
                this.age = age;
        }
} 

အထက်ပါ setAge(int age) လုပ်ဆောင်​ချက်​ကို အသုံးပြု​မည် ဆို​ပါ​က

• User ၏ age အချက်အလက်​သည် private အတိုင်း​ပင်​ဖြစ်​၏။
• setAgeလုပ်ဆောင်​ချက်​ကို အသုံးပြု​မည် ဆို​ပါ​က ပြင်​ပ​မှ​လည်း အချက်အလက်​များ​ကို ပြုပြင်​ပြောင်း​လည်း​နိုင်​မည် ဖြစ်​သည်။
• setAge လုပ်ဆောင်​ချက် အတွင်း​တွင်​လည်း age သည် Object မှ​ပိုင်ဆိုင်​သော age ထက်​ကြီး​မှ​သာ ပြောင်း​လည်း​မည်​ဟု စစ်ဆေး​နိုင်​ပါ​သ​ဖြင့် အချက်အလက်​များ​ကို လုံခြုံ​မှု့​ရှိ​စေ​ပါ​သည်။

အမြန်မှတ်ရန်

Encapsulation ပြုလုပ်မည်ဆိုပါက private မှ​စ​ပါ။ အသုံးလို​သ​လို စဉ်းစား​သွား​မည် ဆို​ပါ​က ပြင်​ပ​ကို ဖော်​ပြ​ရန်လို​တဲ့ အချက်အလက်​နဲ့ လုပ်ဆောင်​ချက်​တွေ​ကို အလိုလို မြင်​လာ​မည် ဖြစ်​သည်။

Class နဲ့ Instance ကို​ကွဲ​အောင်​လုပ်​ပါ

Java ကို​လေ့​လာ​ရာ​တွင် ဦးစွာ​တွေ့​ကြုံ​ရ​မည့် အခက်​အခဲ​များ​ကတော့ Classဆို​တာ​ဘာ​လဲ၊ ပြီး​တော့ Instanceဆို​တာ​ဘာ​လဲ ဟုခေါ်​သော မေးခွန်း​များ​ဖြစ်​ကြ​ပါ​သည်။ ဤ Javaကို​အမြန်​ဆုံး​လေ့​လာ​ခြင်း အခန်း​ဆက် ဘ​လော့​ထဲ​မှာ​တော့ Object Oriented Programming ရဲ့​အမြင်​က မဟုတ်​ပဲ၊ Memoryပေါ်​က Program တစ်​ခုပေါ်​တွင် တည်​ရှိ​သော အမြင်​ပိုင်း​ဆိုင်​ရာ ရှု့​ထောင့်​မှ Classနဲ့ Instance တို့​ရဲ့ ကွဲ​ခြား​ချက်​တွေ​ကို လေ့​လာ​သွား​ပါ​မည်။
Class ဆို​သည်မှာ အဲ့​ဒီ​အစု​အစည်း​ရဲ့ တန်ဖိုး​တွေ​ကို​သတ်​မှတ်ရန်အတွက် အချက်အလက်များ (Field)နဲ့၊ လုပ်ဆောင်​ချက် (Method)များ​ကို စုစည်း​ထား​တဲ့ အစု​အစည်း​တစ်​ခု​လို့​သတ်​မှတ်ထား​၏။ ဤ​ရှင်းလင်း​ချက်​ကို ကြည့်​ရုံဖြင့် Class နဲ့ Instance ကို​ကွဲပြား​ပြီး သိရှိ​နိုင်​မည်​မဟုတ်​ပေ။ ဤသို့ဆိုလျှင် Class နဲ့ Instance ကွာခြားချက်သည် အဘယ်နည်း ဟုမေးစရာရှိပါမည်။ Java နှင့် ပတ်သက်သော စာအုပ်ပေါင်းများစွာတွင် နားလည်လွယ်စေရန် နည်းအမျိုးမျိုးဖြင့် ရှင်းပြထားလေ့ရှိ၏။ ကျွှန်တော်အနှစ်အသက်ဆုံး အဖြေမှာ ကွန်ပျူတာ Memory အပေါ်တွင် ဖြစ်ပေါ်လာပုံ၏ ဒါ​မှ​မဟုတ် ဇာစ်​မြစ် ဟာ​ကွဲပြားခြားနားသည် ဟူသော ရှင်းလင်းချက်ပဲ ဖြစ်ပါသည်။

Class ရဲ့ ဇာစ်​မြစ်​သည် .java ဖိုင်​ကို Compileလုပ်​ပြီး၊ ရ​ရှိ​လာ​တဲ့ .class ဖိုင် ဖြစ်​ပါ​သည်။ Program တစ်​ခု​မှ Class ကို​ဆက်​သွယ် အသုံးပြု​မည် ဆို​လျှင် .class ကို​ဖတ်​ယူ​ပြီး Memoryပေါ်​တွင် Class အဖြစ် နေရာ​ချထား​ပါ​မည်။ တ​ဖန် Instance သည် Memoryပေါ်​တွင် တည်​ရှိ​ပြီး​ဖြစ်​သော Class ကို​အသက်​သွင်း​၍ Memory ပေါ်​မှ​အခြား​သော​နေရာ​တွင် ဖြစ်ပေါ်​လာ​စေ​ပါ​သည်။ မှတ်​ရန်​အချက်​မှာ Classသည် .class ဖိုင်​တစ်​ခု​မှ တစ်​ကြိမ်​တည်း​သာ ဖတ်​ယူ​မွေး​ဖွား​ပြီး၊ Instanceသည် Memory ပေါ်​တွင်​တည်​ရှိ​ပြီး​ဖြစ်​သော Class မှ Memory ရှိ​သ​လောက် အကြိမ်ကြိမ် ကူး​ယူ​မွေး​ဖွား​နိုင်​ခြင်း ဖြစ်​ပေ​သည်။

အမြန်​မှတ်ချက်

Class နှင့် Instanceတို့​သည်၊ တန်ဖိုး​နှင့် လုပ်ဆောင်​ချက်​များ​ကို စုစည်း​ထား​သည့်​အချက်​မှာ တူညီ​ကြ​ပေ​သည်။ သို့ရာတွင် Class သည် .class ဖိုင်​မှ တစ်​ကြိမ်​တည်း​သာ ဖတ်​ယူ​မွေး​ဖွား​ပြီး၊ Instanceသည် Memoryပေါ်​တွင်​တည်​ရှိ​သော Classမှ​တစ်​ဆင့် အကြိမ်ကြိမ် ကူး​ယူ​မွေး​ဖွား​နိုင်​ခြင်း တို့​က​ကွဲပြား​ချက်​တို့ ဖြစ်​ကြ​ပါ​သည်။

သည်လို​ဆို​ရင်Classနဲ့Instanceကို ဘယ်​လို​ခွဲ​ခြား​ပြီး အသုံး​ချ​သင့်​တယ်​ဆို​တာ​ကို လက်တွေ့Codeကို​ရေး​ပြီး လေ့​လာ​ကြည့်​ရအောင်။ အောက်​ပါ　န​မှု​နာ​တွေ​ကို​ကြည့်⁠ကြည့်​ကြ​ပါ။　အသီး​သီး　class A နဲ့ Bကို​ရေးသား​ထား​ပြီး TestClassမှ​နေ ခေါ်​ယူ​အသုံးပြု​ထား​ပါ​သည်။ class A နဲ့ Bတို့​ရဲ့ ကွဲပြား​ချက်​ကို​လေ့​လာ​ကြည့်​ကြ​ပါ​ဆို့။
class A

public class A {
    static int i;
    static int getTwice() {
        return i*2;
    }
}

class B

public class B {
    int i;
    public int gatTwice() {
        return i * 2;
    }
}

Class AရောBပါ၊ ကိုယ်စီ Member Fieldအနေ​နဲ့ int i ကို​ပိုင်ဆိုင်​ပြီး၊ လုပ်ဆောင်​ချက် int တန်ဖိုး​ကို​ပြန်​ပေး​တဲ့ getTwice methodကို ပိုင်ဆိုင်​ကြ​ပါ​တယ်။ class A ရဲ့ i နဲ့ getTwice() ဟာ Classကို​တိုက်ရိုက်​ဆက်​သွယ်​ပြီး အသုံးပြု​နိုင်​ဖို့​အတွက် အရှေ့​မှာ staticဆို​ပြီ သတ်​မှတ်ချက်​ကို ရေးသား​ရ​ပါ​တယ်။ အဲ့​ဒီ​လို​ရေးသား​ထား​တဲ့ Fields တွေ​နဲ့ method တွေ​ကို static field, static methodဆို​ပြီး ခေါ်ဝေါ်​လေ့​ရှိ​ပါ​တယ်။
တ​ဖန် class B မှာ​ရှိ​တဲ့ field နဲ့ method တွေ​ရဲ့​ရှေ့​မှာ static ဆို​တာ​မ​ရေးသား​ထား​ပါ​ဘူး။ အဲ့​ဒါ​ဟာ class B မှ​တ​ဆင့် ပွား​ယူ​နိုင်​တဲ့ instanceတွေ​မှ​တ​ဆင့် အသုံးပြု​စေ​နိုင်​ဖို့​အတွက် ဖြစ်​ပါ​တယ်။ အဲ့​ဒီ​အတွက် instance field, instance method ဆို​ပြီးခေါ်ဝေါ်​လေ့ ရှိ​ပါ​တယ်။
class Test

public class Test {

    public static void main(String [] args) {
        A.i = 10;
        System.out.println("Twice Of Class A : " + A.getTwice());

        B b = new B();
        b.i = 10;
        System.out.println("Twice of Instance b : " + b.gatTwice());
    }
}

Test Classထဲ​မှာ​တော့ class A နဲ့ B တို့​ရဲ့ အသုံးပြု​ပုံ​တွေ​ကို ဖော်​ပြ​ပေး​နေ​ပါ​တယ်။ A.i ဆို​တဲ့ class field i ရဲ့​တန်ဖိုး​ကို 10ဆို​ပြီး​သတ်​မှတ်​နေ​ပါ​တယ်။ ပြီး​သော​အခါ A.getTwice()ဆို​ပြီး A class ရဲ့ getTwiceလုပ်ဆောင်​ချက်​ကို ခေါ်​ယူ​ပြီး system consoleမှာ​ရေးသား​စေ​ပါ​တယ်။ A class ရဲ့ i နဲ့ getTwice ကို static အနေ​နဲ့ သတ်​မှတ်ထား​တဲ့​အတွက် class A မှ တိုက်ရိုက်​အသုံး​ချ​နိုင်​ခြင်း ဖြစ်​ပါ​တယ်။
တ​ဖန် class B ရဲ့ instance b ကို B b = new B(); ဆို​ပြီး သတ်​မှတ်​ပေး​နေ​ပါ​တယ်။ နောက်​တစ်​ကြောင်း​တွင် b.i = 10ဆို​ပြီး instance b ရဲ့ i ရဲ့​တန်ဖိုး​ဟာ 10 ဖြစ်​ပါ​တယ် လို့​သတ်​မှတ်​နေ​ပြန်​တယ်။ ဆက်​ပြီး instance methodဖြစ်​တဲ့ b.getTwiceကိုခေါ် ပြီး System Consoleမှာ ရေးသား​နေ​ပါ​တယ်။ b instance မှ​နေ​အသုံးပြု​နိုင်​ရန် အတွက် သူ့​ရဲ့ Field နဲ့ methodရဲ့​ရှေ့​မှာ staticဆို​တာ မ​ရေးသား​ထား​ပါ​ဘူး။ အဲ့​ဒီ​လို instance field နဲ့ instance method တွေ​ရှိ​တဲ့​အတွက် B classရဲ့ instance b မှ​တ​ဆင့် အသုံးပြု​နိုင်​ခြင်း​ဖြစ်​ပါ​တယ်။

အမြန်​မှတ်ချက်

Class ရဲ့ static field နဲ့ static methodတွေ​ဟာ memory ပေါ်​မှာ တစ်​ကြိမ်​တည်း​သာ ဖြစ်​တည်​တယ်​ဆို​တဲ့ ထူးခြား​ချက်​ကို အသုံး​ချ​ပြီး Class field နဲ့ လုပ်ဆောင်​ချက် တွေ​ကို​ရေးသား​သင့်​ပါသည်။

တ​နည်း​တွေး​ကြည့်​ကြ​ရအောင်။ class A ကို​ရော instance မ​လုပ်​နိုင်​ဘူး​လား။ လုပ်​နိုင်​ပါ​တယ်။ ဒါ​ပေ​မယ့် class A မှာ static field နဲ့ static method သာ​ပိုင်ဆိုင်​ပြီး insatance fieldတွေ methodတွေ မ​ပါ​တဲ့​အတွက် သူ့​ရဲ့ instance ကို​ပွား​ယူ​လုပ်​အောင် အဓိပ္ပါယ်​မ​ရှိ​နိုင်​ပါ​ဘူး။
ဒါ​ဖြင့် Classလည်း​အဲ​လုပ်​လို့​ရ​တယ်၊ instanceလည်း​အလုပ်​လုပ်​လို့​ရ​တယ်။ ဘာ​လို့ instanceက​လို​အပ်​ရ​တာ​လဲဆို​တာ​ကို စဉ်းစား​ကြည့်​ကြ​ရအောင်။ အောက်​ပါ Personဆို​တဲ့ Classကို​ကြည့်​ပါ။ name နဲ့ ageဆို​တဲ့ instance fieldကို​ပိုင်ဆိုင်​ပြီး introdude() ဆို​တဲ့ instance methodရယ် Person(String name, int age)ဆို​တဲ့ constructor ကို​ပိုင်ဆိုင်​ပါ​တယ်။ Constructorဟာ instance တွေ​ကို ပွား​ယူ​တဲ့​အခါ​မှာ အမြဲ​တမ်းခေါ်​ယူ​ခံ​ရ​မည့် လုပ်ဆောင်​ချက်​တစ်​ခု​ဖြစ်​ပါ​တယ်။ Classမှ​တ​ဆင့် instanceကို လုပ်​ယူ​တဲ့​အခါ​မှာ လုပ်ဆောင်​ရ​မည့် လုပ်ဆောင်​ချက်​ဆို​ရင်​လည်း မ​မှား​နိုင်​ပါ​ဘူး။
သည်Person Constructor ကတော့ String name နဲ့ int age ကို Argumentအနေ​နဲ့ လက်ခံ​ရ​ယူ​ပြီး၊ instance member ဖြစ်​ကြ​တဲ့ name နဲ့ ageမှာ အသီး​သီး အစားထိုး​သတ်​မှတ်​နေ​ပါ​တယ်။ ပြီး​တော့ လုပ်ဆောင်​ချက် introduceထဲ​မှာ​တော့ သူ့​ရဲ့ name နဲ့ ageကို System Consoleမှာ ရေးသား​ပြ​နေ​ပါ​တယ်။
class Person

public class Person {
    String name;
    int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public void introduce() {
        System.out.print("My name is " + name);
        System.out.println(" and I am " + age + "years old.");
    }
}

အောက်​ပါ Test class ထဲ​မှာ​တော့ Person ရဲ့ a instance နဲ့ b instance ကို​လုပ်​ယူ​ပြီး အသီး​သီး​ရဲ့ introduceလုပ်ဆောင်​ချက်​ကို လုပ်ဆောင်​စေ​ပါ​တယ်။

classTest

public class Test {   
    public static void main(String [] args) {

        Person a = new Person("Aung Aung", 30);
        Person b = new Person("Thida", 24);
        a.introduce();
        b.introduce();
    }
}

အထက်​ပါ Test Classကို Run ကြည့်​မည်​ဆို​ပါ​က System Console မှာ အောက်​ပါ​အတိုင်း စာ​ကြောင်း​များ​က ထွက်ပေါ်​လာ​ပါ​လိမ့်​မည်။
My name is Aung Aung and I am 30years old.
My name is Thida and I am 24years old.
အထက်ပါ န​မှု​နာ​ကို​ကြည့်​ခြင်း​အား​ဖြင့် Classတစ်​ခု​မှ မ​တူညီ​သော​တန်ဖိုး​များ​နှင့် မ​တူညီ​သော Instanceများ​ကို အကြိမ်ကြိမ် လုပ်​ယူ​နိုင်​တယ် ဆို​တာ​ကို သိရှိ​နိုင်​ပါ​တယ်။

အမြန်​မှတ်ချက်

Constructorမှ​တ​ဆင့် ပုံစံ​ချ​ယူ​ခြင်း​အား​ဖြင့် Class တစ်​ခု​မှ​နေ Instanceကို အကြိမ်ကြိမ်​ပွား​ယူ​နိုင်​ပါ​သည်။

အလွယ်​ဆုံး​ပြော​ရ​မည်​ဆို​လျှင် Classနဲ့ Instance ဟာ ဒယ်အိုး​နဲ့ ဘိန်း​မုန့်​လို​ပါ​ပဲ။ ဒယ်အိုး​တစ်​လုံး​လို​ပဲ Classဟာ​တစ်​ခု​တည်း​ရှိ​ပြီး၊ ဒယ်အိုး​ထဲ​မှာ​ပါဝင်​တဲ့ အစာ​တွေ​ကို အမျိုး​မျိုး​ပြောင်း​ထည့်​ပြီး၊ ထော​ပါတ်​ဘိန်း​မုန့်​တွေ ရိုး⁠ရိုး​ဘိန်း​မုန့်​တွေ​ကို ဖုတ်​ယူ​နိုင်​သ​လို၊ Classတစ်​ခု​မှ တန်ဖိုး​အမျိုး​မျိုး​ပြောင်း​လည်း​ပြီး Instanceတွေ​ကို အမျိုး​မျိုး​လုပ်​ယူ​နိုင်​ပါ​တယ်။
Class နဲ့ Instanceတို့​ရဲ့ ကွဲ​ခြား​ချက်​ကို​သိရှိ​ပြီး Javaဆန်​တဲ့ Codeများ​ကို​ရေးသား​သွား​ကြ​ပါ​ဆို့။

Class နှင့် Method

အခြေခံ ပရိုဂရမ်မင်း ခေါင်းစဉ်ဖြင့် Java ပရိုဂရမ်မင်း၏ အခြေခံသဘောတရားများကို ဖော်ပြခဲ့သည်မှာ ၅ကြိမ်မြောက်ရှိပြီ ဖြစ်၏။ Script ဘာသာရပ်များဆိုလျှင် ဤအခြေအနေလောက်ဆိုလျှင် တော်ရုံ ပရိုဂရမ်များ စရေးနိုင်ပြီထင်၏။ သို့ရာတွင် Java မှာမူ မရေးနိုင်သေးပေ။ ကိန်းများ၊ သင်္ကေတများနှင့် ကွန်တရိုးများရလျှင် တော်ရုံ လော့ဂျစ်များကို စဉ်းစားနိုင်မည် ဖြစ်၏။ သို့ရာတွင် ဤအရာမှာ နိုင်ငံခြားဘာသာစကား သင်စလူတစ်ယောက်နှင့် တူ၏။ အရမ်းလည်းပြောချင်နေပြီ။ သို့ရာတွင် တစ်ခုခုလိုနေသလို။ ပြန်စဉ်းစားကြည့်မည် ဆိုလျှင် ဤပြောလိုစိတ်သည် အလွန်အရေးကြီးပါသည်။

ကျွှန်တော် တက္ကသိုလ် ပဋ္ဌမနှစ် တက်တုန်းက အကြောင်းကို ပြန်စဉ်းစားမိပါသည်။ Java အတန်းတက်ရင်း တစ်ရက် ကျောင်းပြေးမိပါသည်။ မှတ်မှတ်ရရ မက်သတ်အကြောင်းကို သင်သည့်အချိန်ဖြစ်၏။ void ဆိုတာဘာလည်း၊ return ဆိုတာဘာလည်း။ ကောင်းကောင်းနားမလည်ပါ။ နောက်တစ်ခေါက် ကျောင်းတက်ချိန်တွင် ရုတ်တရက် ဆရာက ပုဒ်စာတစ်ခုချပေးပါသည်။ မက်သတ်ကိုသုံးပြီး၊ ပါရာမီတာအလိုက် လုပ်ဆောင်ပုံများကို အမျိုးမျိုးခွဲစေနိုင်သော ပုဒ်စာဖြစ်ပါသည်။ သို့ရာတွင် ကျွှန်တော်မှာ ပြီးခဲ့တဲ့အပါတ်က ကျောင်းပြေးမိပါသဖြင့် နားမလည်လိုက်ပါ။ မက်သတ်ကို ဘယ်လိုသုံးရမှန်းမသိ။ ဒါပေမယ့် ကွန်တရိုးတွေနဲ့ ကိန်းကိုသိပါသည်။ ပြီတော့ main ထဲကနေ ပြီးခဲ့တဲ့သင်ခန်းစာတွေတုန်းက ရေးဘူးပါသည်။ ကဲမထူးဘူးဆိုပြီး၊ ရှိသမျှခေါင်းထဲက အကြံတွေထုတ်ပြီး ဖြစ်အောင်ရေးခဲ့ပါသည်။ ပြီးတော့ ဆရာက ခေါ်ပြီး ဘာလို့ မက်သတ်ကို မသုံးတာလဲဟုမေးသည်။ ကျွှန်တော်က မက်သတ်ဆိုတာဘာလဲ ဟုပြန်မေးပါသည်။ အဲ့ဒီမှာ ကျောင်းပြေးတာပေါ်ပါတော့သည်။ ဒါပေမယ့် အားလုံးရဲ့စာစစ်ပြီးတဲ့အချိန်မှာ ဆရာက ကျွှန်တော်ရေးတဲ့ ပရိုဂရမ်ကို နမှုနာပြပြီး ပရိုဂရမ်ဆိုတာ ဘယ်လိုရေးရေးရတဲ့အကြောင်းကို ဖော်ပြခဲ့ပါသည်။

မှန်၏၊ ပရိုဂရမ်ဆိုသည်မှာ လိုချင်တာကို ဖြစ်ရင် မှန်ပါသည်။ ရေးပုံရေးနည်း အမျိုးမျိုးရှိ၏။ ရေးမည်ဆိုလျှင် အစင်ဘလာ ဘာသာရပ်ကဲ့သို့ အစမှ အဆုံး တောက်လျှောက် ရေးချသွားနိုင်၏။ အသုံးပြုနည်းများကို ကြွယ်ကြွယ်ဝဝ အသုံးပြုပြီး၊ ရှင်းလင်းစွာလည်း ရေးသားနိုင်၏။ ရှည်လွန်း၍ ရှုပ်ထွေးသော ပရိုဂရမ်နှင့် လိုရင်းတိုရှင်း ပရိုဂရမ်မှာ ဘယ်အရာကောင်းသနည်း။ မေးစရာတောင်လိုမည် မဟုတ်။ စာလုံးတစ်လုံးပိုရေးရလျှင် စာလုံးတလုံးစာ လက်ပိုညောင်းပါသည်။ တတ်နိုင်လျှင် စိတ်ကူးရုံနဲ့ အလုပ်လုပ်ပေးနိုင်သော ပရိုဂရမ်သည် အကောင်းဆုံး ဖြစ်ပါလိမ့်မည်။

အဲ့ဒီအတွက် ကျွှန်တော်တို့ ဘာတွေကိုလေ့လာဖို့ လိုအပ်သနည်း။ ပရိုဂရမ်မင်းဘာသာရပ်များသည် ကိုယ်စီ ထူးခြားချက်များကို ပိုင်ဆိုင်၏။ ပြောစရာတောင်လိုမည် မထင်၊ Java သည် Class ကို အခြေခံသော Object Oriented ပရိုဂရမ်မင်းဘာသာရပ်ဖြစ်၏။ ကျွှန်တော်တို့ ဒီတစ်ခေါက် Java ၏ Class နှင့် ၎င်း၏ အသုံးပြုပုံတို့ကို လေ့လာသွားပါမည်။

Class ဆိုသည်မှာ

Java သည် Class ကို အခြေခံသော Object Oriented Programming ဘာသာရပ် တစ်မျိုးဖြစ်၏။ Class ဆိုသည်မှာ Object တစ်ခု၏ အရည်အချင်းများကို ဖော်ပြနိုင်ရန်အတွက် လိုအပ်သော အကြောင်းအရာများကို စုစည်းထားသော အချက်အလက် အစုအစည်းတစ်ခု ဖြစ်ပါသည်။

ဥပမာအားဖြင့် လက်တွေ့ဘဝအား ကွန်ပျူတာ မံမိုရီ အပေါ်ခေါ်ယူ အသုံးချခြင်းကို စဉ်းစားကြည့်ပါမည်။ စားသောက်ဆိုင် တစ်ဆိုင်ရှိပါမည်။ အထက်ပါပုံကို java ပရိုဂရမ်တစ်ခု ရေးရန် စဉ်းစားကြည့်ပါမည်။

ထိုဆိုင်အတွင်းတွင် အောင်အောင်၊ မနီလာနှင့် မသန္တာတို့ ရှိကြသည် ဟု ဆိုကြပါစို့။ မနီလာနှင့် မသန္တာတို့သည် ဧည့်သည်ဆိုသည့် ကလပ်စ်မှ instance လုပ်ထားသော object များဖြစ်ကြပြီး၊ အောင်အောင်သည် စာပွဲထိုး ဆိုသည့် ကလပ်စ်မှ instance လုပ်ထားသော object ဖြစ်ပါသည်။

စာပွဲထိုးနှင့် ဧည့်သည်တို့သည် ကလပ်စ်များဖြစ်ကြပြီး၊ စာပွဲထိုးဆိုသည့်ကလပ်စ်တွင် စာပွဲထိုးတစ်ယောက် ပိုင်ဆိုင်သင့်သည့် အချက်အလက်များနှင့် စာပွဲထိုးက လုပ်ဆောင်နိုင်သော လုပ်ဆောင်ချက်များကို သက်မှတ် ရေးသားထားပါသည်။ ဥပမာအားဖြင့် သူ၏ အမည်၊ ရာထူးအဆင့်အတန်း၊ လစာ၊ လုပ်သက်၊ အရည်အချင်းများ အစရှိသည့်အချက်အလက်များအပြင် အော်ဒါမှာယူခြင်း၊ အရက်စပ်ခြင်း၊ စားပွဲများကိုပို့ပေးခြင်း၊ သိမ်းဆည်းခြင်း အစရှိသည့် လုပ်ဆောင်ချက်များကိုလည်း ပြင်ဆင်ထားရန် လိုအပ်ပါသည်။ တဖန် အောင်အောင်သည် စာပွဲထိုးကလပ်စ်၏ အင်းစတန့်စ် (instance) လုပ်ထားသော အော့ဘဂျက် (Object) ဖြစ်ပါသဖြင့် အောင်အောင် အော့ဘဂျက်သည် စပွဲထိုကလပ်စ်၏ လုပ်ဆောင်ချက်များကို လုပ်ဆောင်နိုင်ပေမည်။ ဥပမာအားဖြင့် အောင်အောင်သည် စာပွဲထိုးဖြစ်ခြင်းကြောင့်၊ အော်ဒါများမှာယူခြင်း၊ အရက်ဖျော်စပ်ခြင်းများကို လုပ်ဆောင်နိုင်ပေမည်။

အကျဉ်းဆုံးဆိုရမည် ဆိုလျှင် အော့ဘဂျက်သည် လက်ရှိလောကတွင်တည်ရှိသော ရုပ်ဝတ္တုများကို ကိုယ်စားပြုထားသော မံမိုရီအပေါ်ရှိ အချက်အလက် အစုအဝေးဖြစ်ပြီး၊ ကလပ်စ်ဆိုသည်မှာ ထိုအော့ဘဂျက်များသည် မည်သည့်အရာဖြစ်သည်ကို သတ်မှတ်ပေးနိုင်သော ဒီဇိုင်းပုံ တစ်ခုဖြစ်ပါသည်။ ပြိုင်ကားတစ်စီး၏ ဒီဇိုင်းပုံအတိုင်း တည်ဆောက်ထားသော ရုပ်ဝတ္တုသည် ပြိုင်ကားတစ်စီးဖြစ်လာပြီး၊ ကုန်တင်ကား ဒီဇိုင်းပုံအတိုင်း တည်ဆောက်ပါက ကုန်တင်ကား တစ်စီးဖြစ်လာမည် ဖြစ်သည်။

ပိုင်ဆိုင်မှု့ အချက်အလက်များ

ကလပ်စ်တစ်ခုသည် အော့ဘဂျက်မှ ပိုင်ဆိုင်သင့်သော အချက်အလက်များနှင့် လုပ်ဆောင်ချက်များကို သက်မှတ်ပေးသည်ဟု ဖော်ပြခဲ့၏။ ပိုင်ဆိုင်မှု့ အချက်အလက်များကို မည်ကဲ့သို့ရေးသားနိုင်သည် ဆိုသည်ကို လက်တွေ့ ကလပ်စ်တစ်ခုကို ရေးသားကြီးရင်း ဖော်ပြပါမည်။

လောလောဆယ် နမှုနာအနေဖြင့် နာမည်မေးလျှင် ပြန်ဖြေတတ်သော Human ဆိုသည့် ကလပ်စ် တစ်ခုကို ရေးသားကြည့်ပါမည်။ Human တွင် အမည်၊ အသက်နှင့် ကျားမကိုဖော်ပြနိုင်သော အချက်အလက်ကို ပိုင်ဆိုင်စေပါမည်။

public class Human {
 
 String name;
 boolean male;
 int age;

}

အထက်ပါအတိုင်း ရေးသားမည်ဆိုလျှင် အမည်၊ လိမ်နှင့် အသက် အစရှိသည့် အချက်အလက်များကို ပိုင်ဆိုင်သော ကလပ်စ် တစ်ခုကို ရေးသားပြီးဖြစ်ပါသည်။ ဆက်လက်၍ ထိုကလပ်၏ အော့ဘဂျက်ကို ရေးသားကြည့်ပါမည်။

public class Human {
 
 String name;
 boolean male;
 int age;
 
 public static void main(String[] args) {
  Human aungaung = new Human();
  aungaung.name = "Aung Aung";
  aungaung.male = true;
  aungaung.age = 22;
  
  System.out.println("Name : " + aungaung.name);
  System.out.println("Age  : " + aungaung.age);
  System.out.println("Male : " + aungaung.male);
 }

}

အထက်ပါ ကုဒ်များကို ကွန်ပိုင်းလုပ်၍ အလုပ်ခိုင်းကြည့်ပါက အောက်ပါအတိုင်း ထိုအော့ဘဂျက်၏ အမည် ၊ အသက်နှင့် လိမ်ကို ဖော်ပြပေးနိုင်ပါသည်။

ရုတ်တရက် ကြည့်မည်ဆိုပါက ဖော်ပြလိုသည်ကို ဖော်ပြနိုင်သဖြင့် ဘာမှ ပြဿနာမရှိသလို ထင်ရမည် ဖြစ်၏။ သို့ရာတွင် အထက်ပါ ကုဒ်များအား main လုပ်ဆောင်ချက်ထဲမှ အောက်ပါအတိုင်း ပြုပြင် ရေးသားကြည့်ပါမည်။

public class Human {
 
 String name;
 boolean male;
 int age;
 
 public static void main(String[] args) {
  Human aungaung = new Human();
  aungaung.name = "Aung Aung";
  aungaung.male = true;
  aungaung.age = 22;
  
  aungaung.male = !aungaung.male;
  
  System.out.println("Name : " + aungaung.name);
  System.out.println("Age  : " + aungaung.age);
  System.out.println("Male : " + aungaung.male);
 }

}

မိန်းလုပ်ဆောင်ချက်အတွင်းတွင် အကြောင်းတစ်ခုခုကြောင့် aungaung အော့ဘဂျက်၏ male တန်ဖိုးကို ပြောင်းပြန်သတ်မှတ်မိပါသည်။ ကွန်ပိုင်းလုပ်ပြီး အလုပ်လုပ်ခိုင်းကြည့်သောအခါ အောင်အောင်သည် ကျားမဟုတ်တော့ပါ။

ဤကဲ့သို့ အော့ဘဂျက်တစ်ခု၏ ပိုင်ဆိုင်မှု့ အချက်အလက်များကို ပြင်ပမှ အလွယ်တကူ ပြုပြင်ပြောင်းလည်းနိုင်လျှင် ထိုအော့ဘဂျက်သည် မိမိကစီမံထားသလို အလုပ်လုပ်နိုင်တော့မည် မဟုတ်ပေ။ ထို့ကြောင့် အချက်အလက်များကို လိုအပ်သလို ပြင်ပမှ အလွယ်တကူ ပြုပြင်ပြောင်းလည်းခြင်း မရှိနိုင်အောင် ပြင်ဆင်ထားသင့်ပါသည်။

Java ဘာသာရပ်တွင် ကလပ်တစ်ခု၏ အချက်အလက်များနှင့် လုပ်ဆောင်ချက်များအား လိုအပ်သလို ဆက်သွယ်ပိုင်ခွင့်ကို သက်မှတ်နိုင်ရန် စကားလုံးများကို ပြင်ဆင်ပါသည်။ ထိုစကားလုံးများမှာ အောက်ပါအတိုင်းဖြစ်၏။

• public မည်သည့်နေရာက မဆို ဆက်သွယ်အသုံးပြုနိုင်ပါသည်။
• protected မိမိ၏ Sub Class များမှ တဆင့် ဆက်သွယ်အသုံးပြုနိုင်ပါသည်။
• private မိမိကိုယ်တိုင်မှလွဲ၍ အခြားသောနေရာများမှ ဆက်သွယ်နိုင်ခြင်းမရှိပါ။

တဖန် ဘာမှ သတ်မှတ်ရေးသားထားခြင်းမရှိပါက၊ package တစ်ခုတည်းအတွင်းမှ ဆိုလျှင် ဆက်သွယ်အသုံးပြုနိုင်ပါလိမ့်မည်။

လုပ်ဆောင်ချက်များ

Java ပရိုဂရမ်တွင် Object များအား အလုပ်လုပ်စေရာတွင် ထို Object ၏ လုပ်ဆောင်ချက်များကို လုပ်ဆောင်စေခြင်းအားဖြင့် ပရိုဂရမ်များကို လိုအပ်သလို အလုပ်လုပ်စေနိုင်ခြင်းဖြစ်သည်။ လုပ်ဆောင်ချက်များအား မက်သတ် (Method) ဟုလည်းခေါ်ဆိုလေ့ရှိပါသည်။

ပိုင်ဆိုင်မှု့ အချက်အလက်များကဲ့သို့ပင် လုပ်ဆောင်ချက်များအားလည်း ဆက်သွယ်အသုံးပြုနိုင်ခွင့်ကို ခွဲခြားရေးသားနိုင်ပါသည်။ လုပ်ဆောင်ချက်များအား ကလပ်စ် အတွင်းတွင် ရေးသားပုံမှာ အောက်ပါအတိုင်းဖြစ်၏။

private String name;

public String getName() {
    return this.name;
}

public void setName(String str) {
    this.name = str;
}

အထက်ပါ ကုဒ်များအတွင်းတွင် String name အချက်အလက်သည် private ဖြစ်ပါသဖြင့်၊ မိမိ၏ အော့ဘဂျက်၏ အပြင်မှ တိုက်ရိုက် ဆက်သွယ်အသုံးပြုနိုင်ခြင်း မရှိပါ။ လုပ်ဆောင်ချက်များကို ရေးသား၍ လိုအပ်သည်များကို လုပ်ဆောင်စေပါသည်။ လုပ်ဆောင်ချက်များကို ရေးသားရာတွင် ဦးစွာ ဆက်သွယ်နိုင်ခွင့် ဖြစ်သော public / private / protected အစရှိသည့် စကားလုံးကို ရေးသားပြီး၊ ရလဒ်၏ အချက်အလက်ပုံစံကိုရေးသားရပါမည်။ ရလဒ်ကိုပြန်ပေးစရာမလိုသော လုပ်ဆောင်ချက်ဆိုပါက void ကို ရေးသားရပြီး၊ int ကို ရလဒ်အဖြစ်ပြန်ပေးလိုပါက int အစရှိသဖြင့် ကနဦးပုံစံများမှအစ၊ Object များအဖြစ်အသုံးပြုနိုင်သော ကိုးကားပုံစံများ အထိ ရလဒ်အဖြစ်ပြန်ပေးနိုင်ပါသည်။

အထက်ပါကုဒ်၏ getName လုပ်ဆောင်ချက်သည် အမည်ကို ရလဒ်အဖြစ်ပြန်ပေးရန် လိုအပ်သည့် လုပ်ဆောင်ချက်ဖြစ်သောကြောင့် public String getName() ဟု ရေးသားပြီး၊ လက်သဲကွင်း { } အတွင်းတွင် ထိုလုပ်ဆောင်ချက်အတွင်းတွင် လုပ်ဆောင်စေလိုသည့် လော့ဂျစ်များကို ရေးသားရပါမည်။ ဤနမှုနာတွင် အမည်ကို ရလဒ်အဖြစ်ပြန်ပေးရန် လိုအပ်ပါသဖြင့် return this.name; ဟု ရေးသားထားပါသည်။ this.name ဆိုသည်မှာ မိမိကပိုင်ဆိုင်သော အချက်အလက်ဖြစ်သည့် name ကို ရလဒ်အဖြစ် ခေါ်ဆိုသည့်နေရာကို ပြန်ပေးနေခြင်းဖြစ်ပါသည်။

တဖန် setName လုပ်ဆောင်ချက်ကို ကြည့်ပါ။ public void setName(String str) ဟု ရေးသားထားသည်။ ပါရာမီတာ String str ကို ပေးပြီး အမည်ကို သတ်မှတ်စေပါသည်။ အတွင်းပိုင်းတွင် this.name = str; ဟု ရေးသားထားပြီး အော့ဘဂျက်၏ name အား ပါရာမီတာ str ဖြင့် အစားထိုးပါသည်။

ဤအတိုင်းဆိုပါက ယခင်ရေးသားခဲ့သော ပိုင်ဆိုင်မှု့ အချက်အလက်များအား တိုက်ရိုက်ဆက်သွယ်သည်နှင့် ဘာမှခြားမည် မဟုတ်ပေ။ ကွာခြားချက်ကို သိရှိစေရန် နမှုနာတစ်ခုကို ရေးသားကြည့်ပါမည်။

public class HumanTest {
 
 private Human aung;
 
 public HumanTest(Human aung) {
  this.aung = aung;
 }
 
 public void init(String name, boolean isMale, int age) {
  this.aung.setAge(age);
  this.aung.setName(name);
  this.aung.setMale(isMale);
 }
 
 public void doOutput() {
  System.out.println("Name : " + this.aung.getName());
  System.out.println("Age  : " + this.aung.getAge());
  System.out.println("Sex  : " + this.aung.getSex());
 }
 
 public static void main(String[] args) {
  HumanTest test = new HumanTest(new Human());
  test.init("Aung Aung", true, 22);
  test.doOutput();
 }
}

class Human {

 private String name;
 private Integer age;
 private Boolean male;
 
 public String getName() {
  String tmp = "";
  if(male) {
   if(age > 30) {
    tmp = "U ";
   } else if (age > 20) {
    tmp = "Ko ";
   } else {
    tmp = "Mg ";
   }
  } else {
   if(age > 30) {
    tmp = "Daw ";
   } else {
    tmp = "Ma ";
   }
  }
  return tmp + name;
 }
 public void setName(String name) {
  this.name = name;
 }
 public int getAge() {
  return age;
 }
 public void setAge(int age) {
  this.age = age;
 }
 public String getSex() {
  if(male) {
   return "Male";
  }
  return "Female";
 }
 public void setMale(boolean male) {
  if(null == this.male) {
   this.male = male;
  }
 }
}

ဒီတစ်ခေါက် ကုဒ်တွေအရှည်ကြီး ရေးသားထားသော်လည်း ကြည့်စေလိုသည်မှာ စာကြောင်း ၁၂နှင့် ၆၈ မှ ၇၂အထိ ဖြစ်ပါသည်။ Human ကလပ်စ်၏ male အား တိုက်ရိုက် သက်မှတ်ခွင့်မရှိတော့သောကြောင့် setMale လုပ်ဆောင်ချက်ကို ပြင်ဆင်လာပါသည်။ ဤကဲ့သို့ လုပ်ဆောင်ချက်ကို ပြင်ဆင်ထားခြင်းအားဖြင့် လုပ်ဆောင်ချက်အတွင်းတွင် male သည် သတ်မှတ်ထားခြင်း မရှိပါမှ သက်မှတ်နိုင်မည်ဟု ပြုပြင် ရေးသားနိုင်ပါသည်။ ဤနည်းအားဖြင့် တစ်ကြိမ် သတ်မှတ်ထားသော အချက်အလက်အား စစ်ဆေး၍ ပြင်ပြင်နိုင်စံရန် စီမံနိုင်ပါသည်။

ကွန်စတရက်တာ (Constructor)

အထက်ပါ ကုဒ်များကိုကြည့်ရင်း မလိုအပ်ပဲ အလွန်ရှည်နေသည်ဟု ထင်မိသူများရှိမည်။ ဟုတ်သည်။ Setter လုပ်ဆောင်ချက်များသည် ပရိုဂရမ်အတွင်းတွင် တစ်ကြိမ်သာသုံးရန်လိုအပ်ပြီး၊ နောက်ပိုင်းတွင် အကြိမ်ကြိမ်ပြန်သုံးနေသည်ကို မတွေ့ရ။ ထို့ကြောင့် အော့ဘဂျက်အားခေါ်ယူစဉ် တစ်ခါရေးပြီး နောက်ပိုင်းတွင် ပြန်သုံးရန်မလိုသဖြင့် တကူးတက Setter လုပ်ဆောင်ချက်များကို ပြင်ဆင်ထားရန် မဖြစ်မနေ လိုအပ်ခြင်းမရှိပေ။

အော့ဘဂျက်အား ခေါ်ယူစဉ်တွင် သတ်မှတ်ရန် နည်းလမ်းရှိပါသည်။ ထိုအရာမှာ Constructor ပင်ဖြစ်၏။ ကွန်စတရက်တာသည် Class တစ်ခုမှ အော့ဘဂျက်အား instance လုပ်ယူသည့်အခါတွင် ခေါ်ဆိုမည့် လုပ်ဆောင်ချက်တစ်ခုဖြစ်သည်။ Java Class များသည် Object Class ၏ Sub Class များဖြစ်သောကြောင့် Parameter ကို အသုံးမပြုသော ကွန်စတရက်တာကို အလိုအလျှောက်ပိုင်ဆိုင်ပါသည်။ တကူးတကရေးစရာမလိုပဲ အလိုအလျှောက် instance ကို ခေါ်ယူနိုင်ပါသည်။

သို့ရာတွင် Class မှ instance ကို ခေါ်ယူလိုသည့်အခါတွင် ကြိုတင်၍ လော့ဂျစ်များကို ရေးသားထားလိုပါက ကွန်စတရက်တာ အတွင်းတွင် ရေးသားထားနိုင်ပါသည်။

public class HumanTest {

 public static void main(String[] args) {
  Human aung = new Human("Aung Aung", 22, true);
  System.out.println("Name : " + aung.getName());
  System.out.println("Age  : " + aung.getAge());
  System.out.println("Sex  : " + aung.getSex());
 }
}

class Human {

 private String name;
 private Integer age;
 private Boolean male;
 
 public Human(String name, int age, boolean male) {
  this.name = name;
  this.age = age;
  this.male = male;
 }
 
 public String getName() {
  String tmp = "";
  if(male) {
   if(age > 30) {
    tmp = "U ";
   } else if (age > 20) {
    tmp = "Ko ";
   } else {
    tmp = "Mg ";
   }
  } else {
   if(age > 30) {
    tmp = "Daw ";
   } else {
    tmp = "Ma ";
   }
  }
  return tmp + name;
 }

 public int getAge() {
  return age;
 }

 public String getSex() {
  if(male) {
   return "Male";
  }
  return "Female";
 }
}

အထက်ပါ ကုဒ်များ၏ စာကြောင်း ၁၇မှ ၂၁သည် ကွန်စတရက်တာဖြစ်ပါသည်။ ထိုကွန်စတရက်တာတွင် ဤကလပ်စ်၏ ပိုင်ဆိုင်မှု့အချက်အလက်များအား သတ်မှတ်ရန် အချက်အလက်များကို ပါရာမီတာအဖြစ် လက်ခံရယူပြီး၊ ကွန်စတရက်တာ အတွင်း၌ပင် အစားထိုးနေပါသည်။ ဤသည်ကို ကြည့်ခြင်းအားဖြင့် Human ၏ instance ကို ခေါ်ယူရာတွင် String name, int age, boolean male ကို ပါရာမီတာအဖြင့် ပေးရန်လိုအပ်သည် ဆိုသည်ကို သိနိုင်ပါသည်။ တနည်းဆိုရသော် ဤနည်းအားဖြင့် ပါရာမီတာအဖြစ်ပေးလိုက်သော အချက်အလက်များကို ပိုင်းဆိုင်သော အော့ဘဂျက်ကို ရရှိနိုင်မည်ဖြစ်သည်။ ကျွှန်တော်တို့ အထက်ပါ ကုဒ်များကို အလုပ်လုပ်ခိုင်းကြည့်ပါက အောက်ပါအတိုင်း ရရှိပါလိမ့်မည်။

လေးစားစွာဖြင့်

မင်းလွင်

ကွန်တရိုးများ

ပရိုဂရမ်ဆိုသည်မှာ အစီအစဉ်များပင်ဖြစ်၏။ ထို့ကြောင့် ပရိုဂရမ်ကောင်းဆိုသည်မှာ အစီအစဉ်ကောင်းများ ဖြစ်ကြပေသည်။ မည်သည့်ပရိုဂရမ်များကို ပရိုဂရမ်ကောင်းများဟု ခေါ်ဆိုမည်နည်း။ မည်သည့် အချိန်အခါမျိုးမှာမဆို ဟာကွက်မရှိအောင် စီစဉ်ထားသော အစီအစဉ်များကို အစီအစဉ်ကောင်းဟု ခေါ်နိုင်ပါသည်။

ပြီးခဲ့သော အခြေခံ ပရိုဂရမ်မင်း အခန်းများတွင် ကိန်းများနှင့် သင်္ကေတများ အကြောင်းကို ဖော်ပြခဲ့၏။ ကိန်းများ သင်္ကေတများဖြင့် အစီအစဉ်ကောင်းတစ်ခုကို ရေးသားရန် မလုံလောက်သေးပါ။

မိုးလေဝသ သတင်းတွင် မိုးရွာမည်ဟု ဖော်ပြထားပါက ထီးယူသွားပါမည်။ ဒါမှမဟုတ်ပါက ထီးမယူသွားပါ။
ညနေ ၆နာရီ မထိုးမချင်း ဘီယာဆိုင်မသွားပါ။ အစရှိသဖြင့် အကြောင်းအရာတစ်ခုခုကြောင့် တစ်ခုခု လုပ်ဆောင်ရန် အသုံးပြုသော စကားလုံးများကို ပရိုဂရမ်မင်းဘာသာရပ်တွင် ကွန်တရိုးများဟု ခေါ်ဆိုလေ့ရှိ၏။

လော့ဂျစ်သုံး ကွန်တရိုးများ

if ဝါကျ


အခြေအနေတစ်ခုကို ဖော်ပြရာတွင် Java ပရိုဂရမ် အတွင်းတွင် if ဝါကျကို အသုံးပြု၍ ဖော်ပြလေ့ရှိပါသည်။

အကယ်၍ မိုးရွာခဲ့လျှင် ထီးဆောင်းသွားပါမည်။

if (မိုးရွာသည်) {
    ထီးဆောင်းသွားပါမည်;
}

Java ဘာသာရပ်တွင် if ဝါကျ၏ အခြေအနေကို ဖော်ပြရာတွင် if ၏ နောက်ရှိ လက်သည်းကွင်းအတွင်းတွင် အခြေအနေဖော်ပြချက်ကို ရေးသားရန် လိုအပ်ပါသည်။ အခြေအနေများသည်၊ တူညီသည်၊ ကြီးမားသည်၊ အစရှိသည့် နှိုင်းယှဉ်ဖော်ပြချက်များကို အသုံးပြုနိုင်ပါသည်။

အသက် ၂၀အောက်ဆိုလျှင် မကြည့်ရပါ။

int age;
...
if (age < 20) {
    မကြည့်ပါနှင့်;
}

ပရိုဂရမ်ဘက်မှကြည့်သောအခါ မိုးရွာသည် ဆိုသည်မှာ မိုးရွာသည်ဆိုသည်မှာ မှန်ပါသည်ဟု အဓိပ္ပါယ်ရပါသည်။

boolean raining;
...
// မိုးရွာလျှင်
if (raining == true) {
    ထီးဆောင်းပါမည်;
}
// တနည်းအားဖြင့်
if (raining) {
    ထီးဆောင်းပါမည်;
}

// မိုးမရွာပါက
if (raining != true) {
    ထီးမဆောင်းပါ;
}

// တနည်းအားဖြင့်
if (raining == false) {
    ထီးမဆောင်းပါ;
}

// ဤကဲ့သို့လည်း
if (!raining) {
    ထီးမဆောင်းပါ;
}

အခြေအနေများကို ဖော်ပြရာတွင် အခြေအနေများကို တစ်ခုခြင်း ဖော်ပြနိုင်သလို ပူးတွဲ၍လည်း ဖော်ပြနိုင်ပါသည်။ မိုးရွာလျှင် ထီးဆောင်းမည်၊ နှင်းကျလျှင် ထီးဆောင်မည် ဆိုသည်ကို မိုးရွာလျှင် ဒါမှမဟုတ် နှင်းကျလျှင် ထီးဆောင်းသွားပါမည်ဟုလည်း ရေးသားနိုင်ပါသည်။ ဒါမှမဟုတ်(OR)ကို Java တွင် || ဟု ဖော်ပြနိုင်ပါသည်။

boolean raining;
boolean snowing;
...
if (raining) {
    ထီးဆောင်းပါမည်;
}

if (snowing) {
    ထီးဆောင်းပါမည်;
}

// အောက်ပါအတိုင်းလည်း ရေးသားနိုင်ပါသည်
if (raining || snowing) {
    ထီးဆောင်းပါမည်;
}

တဖန် မိုးရွာ၍ လေထန်ပါက ကဲ့သို့သော အခြေအနေနှစ်ခုကိုလည်း AND ဖော်ပြပုံကို အသုံးပြု၍ ဖော်ပြနိုင်ပါသည်။ Java ဘာသာရပ်တွင် AND အား && ဟုရေးသားနိုင်ပါသည်။

boolean raining;
boolean winding;
...
if (raining && winding) {
    ထီးဆောင်းပါမည်;
}

if / else ဝါကျ

"မိုးရွာလျှင် ထီးဆောင်း၍၊ မိုးမရွာပါက ထီးမဆောင်းပါ" ကဲ့သို့သော ဝါကျများကို အခြေအနေကို တစ်ခုချင်းဖော်ပြနိုင်သကဲ့သို့၊ "အကယ်၍ မိုးရွာခဲ့ပါက ထီးဆောင်မည်။ သို့မဟုတ်ပါက ထီးမဆောင်းပါ" ဟု if / else ကို အသုံးပြု၍ ရေးသားနိုင်ပါသည်။

if (raining) {
    ထီးဆောင်းမည်;
} else {
    ထီးမဆောင်းပါ;
}

if / else if / else ဝါကျ

if else ထက်မက အခြေအနေများကို ကွန်တရိုးလုပ်လိုပါက if / else if / else ဝါကျကို အသုံးပြုနိုင်ပါ။

if (အခြေအနေ၁) {
    အလုပ်၁;
} else if (အခြေအနေ၂) {
    အလုပ်၂;
} else {
    အခြားသော အလုပ်;
}

switch ဝါကျ

အခြေအနေများကို အသုံးပြုရာတွင် if / else if / else အပြင် switch ဝါကျကို အသုံးပြုနိုင်ပါသေးသည်။ switch ဝါကျတွင် အသုံးပြုနိုင်သော ပါရာမီတာများ၏ ပုံစံများမှာ ကနဦးပုံစံများနှင့် ၎င်း၏ ရက်ပါပုံစံ အော့ဘဂျက်များ၊ ထို့အပြင် Java 7 မှစ၍ String ပုံစံများကိုလည်း အသုံးပြုလာနိုင်ပါသည်။

    public static void main (String [] args) {
        String param = args [0];

        switch (param) {
        case "sunday":
            System.out.println("Today is a holiday.");
            break;
        case "monday":
            System.out.println("Today is not a holiday.");
            break;
        case "tuesday":
            System.out.println("Today is not a holiday.");
            break;
        case "wednesday":
            System.out.println("Today is not a holiday.");
            break;
        case "thursday":
            System.out.println("Today is not a holiday.");
            break;
        case "friday":
            System.out.println("Today is not a holiday.");
            break;
        case "saturday":
            System.out.println("Today is a holiday.");
            break;
        default:
            break;
        }
    }

တဖန် အောက်ပါကဲ့သို့လည်း တူညီသော အရာများကို ပူးတွဲ၍ ရေးသားနိုင်ပါသည်။

    public static void main (String [] args) {
        String param = args [0];

        switch (param) {
        case "saturday":
        case "sunday":
            System.out.println("Today is a holiday.");
            break;
        case "monday":
        case "tuesday":
        case "wednesday":
        case "thursday":
        case "friday":
            System.out.println("Today is not a holiday.");
            break;
        default:
            break;
        }
    }

တဖန် အထက်ပါအခြေအနေမျိုးကို if / else if နှင့် လည်း အသုံးပြုနိုင်ပါသည်။

    public static void main (String [] args) {
        String param = args [0];

        if ("saturday".equals(param) ||
            "sunday".equals(param)) {
            System.out.println("Today is a holiday.");
        } else if ("monday".equals(param) ||
            "tuesday".equals(param) ||
            "wednesday".equals(param) ||
            "thursday".equals(param) ||
            "friday".equals(param)) {
            System.out.println("Today is not a holiday.");
        }
    }

ဤကဲ့သို့ ရေးသားရာတွင် အစဉ်ပြေသလိုရေးသားနိုင်ပါသည်။ if else က ကောင်းသလား၊ switch က ကောင်းသလား ဆိုတာကတော့ ဖြေရအတော်ခက်ပါမည်။ ကွန်တရိုးလုပ်ရမည့်အချက်များ နည်းမည်ဆိုပါက လွယ်လင့်တကူ if else ကို အသုံးပြုသည်က မြန်ဆန်ရှင်းလင်းပါသည်။ သို့ရာတွင် အကြောင်းအရာများ များလာမည် ဆိုပါက if else တွေများလာလျှင် ကုဒ်များသည် ရှုပ်ထွေးလာတတ်ပြီး၊ မှားယွင်းလွယ်ကူစေနိုင်ပါသည်။ ထိုအခါမျိုးတွင် switch ဝါကျကို အသုံးပြုသည်က အမြင်ရှင်းလင်းပါသဖြင့် အမှားအယွင်း နည်းပါးစေနိုင်ပါသည်။

loop ဝါကျများ

လုပ်ဆောင်ချက်များကို အကြိမ်ကြိမ် အလုပ်လုပ်စေလိုသည့် အခါမျိုးတွင် Java နှင့် while , do while နှင့် for ဝါကျများကို ပြင်ဆင်ထားပါသည်။

အောက်ပါဝါကျကိုကြည့်ပါ။

public static void writeFiveTimes() {
    System.out.println("1: writing");
    System.out.println("2: writing");
    System.out.println("3: writing");
    System.out.println("4: writing");
    System.out.println("5: writing");
}

အထက်ပါအတိုင်း ရိုးရှင်းစွာ ၅ကြိမ်ရေးသားနိုင်ပါသည်။


do while ဝါကျနှင့် while ဝါကျ

အကြိမ်ကြိမ် အလုပ်လုပ်စေလိုသည့်အခါမျိုးတွင် do while ဒါမှမဟုတ် while ဝါကျကို အသုံးပြုနိုင်ပါသည်။ အောက်ပါ ရေးသားပုံကိုကြည့်ပါ။ စာကြောင်း ၃မှ ၅အကြားရှိ လုပ်ဆောင်ချက်အား၊ စာကြောင်း ၅တွင်ဖော်ပြထားသည့် အခြေအနေအတိုင်းဆိုပါက အကြိမ်ကြိမ် လုပ်ဆောင်နေမည် ဖြစ်သည်။

public static void writeFiveTimes() {
    int i = 1;
    do {
        System.out.println(++i + ": writing");
    } while (i < 5);
}

အထက်ပါ ရေးသားပုံထဲတွင် i သည် ၅ထပ်ငယ်ပါက စာကြောင်း ၄ကို လုပ်ဆောင်စေမည်ဖြစ်သည်။ စာကြောင်း ၄တွင် ++i ဖြင့် i အား တစ်ပေါင်းနေပါသဖြင့် တစ်ကြိမ်လုပ်ပြီးလျှင် i သည် ၂ဖြစ်ပြီး၊ ၅ကြိမ်ရေးပြီးပါက i သည် ၅ ဖြစ်သွားပြီး ဤ do while ဝါကျအတွင်းမှ လွတ်မြောက်မည် ဖြစ်၏။

အထက်ပါ ရေးသားပုံကိုလည်း while တစ်ခုတည်းဖြင့်လည်း ရေးသားနိုင်ပါသည်။

public static void writeFiveTimes() {
    int i = 1;
    while (i < 5) {
        System.out.println(++i + ": writing");
    }
}

for ဝါကျ

အကြိမ်ကြိမ် လုပ်ဆောင်စေသည့် ကွန်တရိုးများကို ရေးသားစေလိုသည့်အခါမျိုးတွင် while အပြင် for ဝါကျကိုလည်း Java တွင် ပြင်ဆင်ထားပါသည်။ ရေးသားပုံမှာ အောက်ပါအတိုင်းဖြစ်၏။

public static void writeFiveTimes() {
    for (int i=0; i < 5; ) {
        System.out.println( ++i + ": writing");
    }
}

အချို့သောအခါများတွင် Array ကဲ့သို့ ကိန်းစဉ်များ၊ List ကဲ့သို့ Collection များကို အကြိမ်ကြိမ်အသုံးပြုလိုသောအခါရှိမည်။ ယခင်ကဆိုလျှင် Iterator ကို အသုံးပြု၍ while ဖြင့် အကြိမ်ကြိမ် လုပ်ဆောင်စေခဲ့ကြပါသည်။ သို့ရာတွင် Java 5 မှစ၍ for ဝါကျပြုပြင် ပြုလုပ်မှု့များကို ဖြည့်စွက်လာပြီး၊ Iterator အဖြစ်ပြောင်းသုံးစရာမလိုတော့ပဲ for ဖြစ်လည်း အသုံးပြုလာနိုင်ပါသည်။

public static void writeFiveTimes() {
    int [] array = {1,2,3,4,5};
    for ( int i : array) {
        System.out.println( ++i + ": writing");
    }
}

breakဖြင့် နှုတ်ထွက်မည်

အထက်ဖော်ပြပါ while၊ do while နှင့် for ဝါကျများဖြင့် အကြိမ်ကြိမ် အလုပ်လုပ်စေနိုင်သည်ကို သိရှိခဲ့ပြီဖြစ်သည်။ သို့ရာတွင် ကိန်းစဉ်တစ်ခုအတွင်းမှ ကိန်းတစ်ခုကို ရှာဖွေသည်ကို စဉ်းစားကြည့်ပါ။ လမ်းခုလတ်တွင် အဖြေတွေ့ရှိသွားပြီဆိုပါက မပြီးမချင်း ဆက်လုပ်ရမည်မှာ သိပ်မနိပ်လှပေ။ အဖြေရသွားလျှင် ဆက်ရှာလည်းထူးမှာမဟုတ်တော့တဲ့အတွက် လမ်းခုလပ်တွင် နှုတ်ထွက်နိုင်ရန် လိုအပ်ပါသည်။ ဤအခါမျိုးတွင် break ကို အသုံးပြု၍ နှုတ်ထွက်နိုင်ပါသည်။

public String search(String [] array, String searchStr) {
    String result;
    for (String s : array) {
        if (searchStr.equals(s)) {
            result=s;
            break;
        }
    }
    return result;
}

စာကြောင်း ၄တွင် ရှာဖွေလိုသည့် searchStr သည် loop လုပ်နေသည့် s နှင့် တူညီပါက၊ စာကြောင်း ၅တွင် အဖြေဖြစ်သော result အား s ဖြင့် အစားထိုးပြီး၊ စာကြောင်း ၆တွင် break ဖြင့် for ဝါကျအတွင်းမှ နှုတ်ထွက်ပါသည်။ နောက်ဆုံး စာကြောင်း ၉ တွင် ရှာဖွေထားသော resultအား return ဖြင့် ဤလုပ်ဆောင်ချက်အား ခေါ်ဆိုနေသည့် နေရာကို ပြန်ပို့ပေးစေပါသည်။

အထက်ပါလုပ်ဆောင်ချက်ကဲ့သို့ ရိုးရှင်းသော လုပ်ဆောင်ချက်များဆိုလျှင် ခပ်ကြမ်းကြမ်း return လုပ်၍လည်းရပါသည်။

public String search(String [] array, String searchStr) {
    for (String s : array) {
        if (searchStr.equals(s)) {
            return s;
        }
    }
    return null;
}

စာကြောင်း ၃တွင် ရှာဖွေလိုသော အဖြေကို တွေ့ပါက စာကြောင်း၄ဖြင့်ထိုအဖြေကို return လုပ်ပါမည်။ နောက်ဆုံး အဖြေကိုရှာမတွေ့ပါက စာကြောင်း ၆ဖြင့် null ကို return လုပ်ရုံပင် ဖြစ်၏။ ရေးသားလိုသည့်လော့ဂျစ်အပေါ်မှုတည်၍ သင့်တော်သလို အသုံးပြုသွားစေလိုပါသည်။ while ဝါကျတွင်လည်း break ကို အသုံးပြု၍ နှုတ်ထွက်နိုင်ပါသည်။


continueဖြင့် ကျော်လုပ်ပါမည်

အောက်ပါအခါမျိုးဆိုလျှင် မည်သို့ပြုလုပ်မည်နည်း။ ကျွှန်တော်တို့ Loop ဝါကျအတွင်းတွင် လုပ်ဆောင်ချက်အမျိုးမျိုးရှိပြီး၊ အနေအထားတစ်ခုခုရောက်လျှင် အောက်ပါ လုပ်ဆောင်ချက်များကို ဆက်မလုပ်ချင်တော့ပါ။ သို့ရာတွင် ဤ loop အတွင်းမှလည်း နှုတ်မထွက်ချင်ဘူး။ အဲ့ဒီလိုအခါမျိုးမှာ continue ကို အသုံးပြုပြီး၊ နောက်အကြိမ်ကို ကျော်လုပ်၍ရပါသည်။ ဤကဲ့သို့အနေအထားမျိုးတွင် if else ကို သုံးပြီး လမ်းများကို ခွဲခြားနိုင်ပေမယ့်၊ for ဝါကျအတွင်းတွင် if else တွေများလာလျှင် nest တွေ နက်နဲလာပြီး၊ စပါဂတ်တီကုဒ်များ (ရှုပ်ထွေးသောကုဒ်များ) ကို ဖြစ်ပွားစေလေ့ရှိသောကြောင့်၊ ရိုးရှင်းစွာ continue ကို အသုံးပြု၍ skip လုပ်နိုင်ပါသည်။ while နှင့် do while တို့တွင်လည်း continue ကို အသုံးပြု၍ Skip လုပ်နိုင်ပါသည်။

public String search(String [] array, String searchStr) {
    for (String s : array) {
        // ရှာဖွေလိုသည့် စာလုံး၏ ပဋ္ဌမစာလုံးဖြင့် မစလျှင်
        if (!s.startsWith(searchStr.subString(0,1))) {
            continue;
        }

        if (searchStr.equals(s)) {
            return s;
        }
    }
    return null;
}

အထက်ပါ ဖော်ပြပါ ကုဒ်များအတိုင်း စာကြောင်း ၄တွင် loop လုပ်နေသော စကားလုံးသည် ရှာဖွေလိုသောစကားလုံး၏ ပဋ္ဌမစာလုံးဖြင့်မစခဲ့ပါက နောက်လော့ဂျစ်ကို မလုပ်ဆောင်တော့ပဲ Skip လုပ်ပြီး၊ နောက်အကြိမ်ကို ဆက်လုပ်မည် ဖြစ်ပါသည်။ ဤနေရာတွင် if ဘလော့အတွင်းသို့ နောက်ဆက်တွဲ လော့ဂျစ်ကို ထည့်သွင်းနိုင်ပါသော်လည်း၊ for အတွင်းရှိ၊ if အတွင်းရှိ if သည် အဆင့်ဆင့်များလာပြီး၊ ပိုမိုရှုပ်ထွေးလာသောအခါ၊ ပရိုဂရမ်မှာ ဖတ်ရခက်ခဲပြီး၊ မှာယွင်းလွယ်ကူသော ပရိုဂရမ်များ ဖြစ်လာတတ်ပါသည်။ ထို့ကြောင့် ပရိုဂရမ်များကို ရေးသားရာတွင် တတ်နိုင်သ၍ တိုရှင်းသော ပရိုဂရမ်များကို ရေးသားရန် အားထုတ်သင့်ပါသည်။

နောက်ဆုံးတွင်

ကျွှန်တော်တို့ Basic Programming ခေါင်းစဉ်ဖြင့်၊ ပရိုဂရမ်ဆိုသည်မှာအဘယ်နည်း၊ ပရိုဂရမ်တွင် အသုံးပြုသော ကိန်းများ၊ သင်္ကေတများနှင့် ကွန်တရိုးများကို လေ့လာခဲ့ပါသည်။ ကျွှန်တော်တို့ ရေးသားလိုသော အစီအစဉ်များကို စဉ်းစား၍ နည်းနည်းချင်း ရေးသားနိုင်ပြီ ဖြစ်သည်။ အကယ်၍ စကရစ်ဘာသာရပ်ဖြစ်ပါက လော့ဂျစ်များကို ရေးပြီး ပရိုဂရမ်များကို အလုပ်လုပ်စေနိုင်ပြီဖြစ်သည်။

သို့ရာတွင် ကျွှန်တော်တို့ ရေးသားလိုသည်မှာ Java ဖြစ်၏။ Java သည် ကလပ်စ်ကို အခြေခံသော ဝတ္တစက္ခုဗေဒ ပရိုဂရမ်မင်း (OOP) တစ်ခုဖြစ်၏။ ကျွှန်တော်တို့ ပရိုဂရမ်ကို ရေးသားနိုင်ရန် ကလပ်စ် နှင့် မက်သတ်များအကြောင်းကို ဆက်ပါဦးမည်။ ပြီးလျှင် Interface , Abstract Class နှင့် Exception Control များ အကြောင်းကို ဖော်ပြပြီး၊ Basic Programming ကို ပြီးဆုံးပါမည်။

Basic Java ကို လေ့လာပြီးသောအခါ Easy Java ကို တစ်ခေါက်ပြန်ဖတ်စေလိုပါသည်။ ပြီးပါမှ Easy Java API ခေါင်းစဉ်ဖြင့် Java တွင်အသုံးများသော အခြေခံ လိုင်ဘရီများကို ဆက်လက် ဖော်ပြသွားပါမည်။ လောလောဆယ်တော့ အခြေခံ ပရိုဂရမ်မင်းကို ပြီးအောင် အားစိုက်ပြီး ရေးသားပါဦးမည်။

ကိုးကား
http://docs.oracle.com/javase/tutorial/java/nutsandbolts/flow.html

လေးစားစွာဖြင့်

မင်းလွင်