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 ခေါင်းစဉ်ဖြင့် ဆက်လက် ဖော်ပြသွားပါဦးမည်။

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

မင်းလွင်