Java developer တစ်ယောက်အနေဖြင့်၊ သင်သည် Java ချွင်းချက်များနှင့်ခြွင်းချက်များကိုင်တွယ်ခြင်းဆိုင်ရာဗဟုသုတကောင်းများရှိသင့်သည်။
ဤသင်ခန်းစာသည် Java ပရိုဂရမ်များနှင့်အလုပ်လုပ်စဉ်ပရိုဂရမ်မာအားလုံးရှိရမည်အခြေခံဗဟုသုတကိုပေးသည်။ စတင်ရန် Java Exception များအတိအကျကိုနားလည်ခြင်းဖြင့်စတင်ကြပါစို့။
Java ပရိုဂရမ်တစ်ခုသည်ပြexecutionနာများဖြစ်ပွားနိုင်ပြီး၎င်းပရိုဂရမ်သည် ၄ င်း၏လုပ်ဆောင်မှုအတွင်းရုတ်တရက်ရပ်တန့်သွားစေနိုင်သည်။ ဤပြproblemsနာများကိုခြွင်းချက်ဟုခေါ်သည်။
ကောင်းမွန်သောပရိုဂရမ်မာတစ် ဦး သည်ကွပ်မျက်မှုကာလအတွင်းပေါ်ပေါက်နိုင်သည့်အမှားများကိုအသိအမှတ်ပြုပြီးထိုအစီအစဉ်မှလွဲလျှင်အခြားလမ်းကြောင်းများကိုပေးသင့်သည်။ ဒီအလေ့အကျင့်ခြွင်းချက်ကိုင်တွယ်ဟုခေါ်သည်။
အခုငါတို့ဘာကြောင့်ခြွင်းချက်ကိုင်တွယ်စရာမလိုအပ်ဘူးလဲလို့သင်တွေးမိနေလိမ့်မည်။ အဘယ်ကြောင့်ချွင်းချက်များချပစ်မည်မဟုတ်ကြောင်းအစီအစဉ်များကိုရေးပါ
ထွက်ပေါ်လာသည့်အခါခြွင်းချက်များကိုချပစ်မည်မဟုတ်သောပရိုဂရမ်များရေးသားခြင်းသည်အသံကဲ့သို့မလွယ်ကူပါ။ အချိန်အများစုမှာဤ ရှောင်လွှဲ၍ မရသောအမှားများသည်ပရိုဂရမ်မာ၏ထိန်းချုပ်မှုအောက်တွင်ရှိသည်။
အသုံးပြုသူထည့်သွင်းမှုကိုလက်ခံသောပရိုဂရမ်များသည်အသုံးပြုသူမှမမှန်ကန်သောထည့်သွင်းမှုကြောင့်ချွင်းချက်များသို့ကျရောက်နိုင်သည်။ ထို့အပြင်ပြင်ပဖိုင်များကိုဖတ်ခြင်းသည်ပရိုဂရမ်မာ၏ဗဟုသုတမရှိပဲ၎င်းတို့အားပြင်ပအရင်းအမြစ်တစ်ခုမှရွှေ့ပြောင်းခြင်း၊
ထိုကဲ့သို့သောအခြေအနေမျိုးတွင်၊ program သည်ကွပ်မျက်မှုကိုမရပ်တန့်ဘဲချွင်းချက်အားလျောက်ပတ်စွာကိုင်တွယ်နိုင်ရမည်။
ဂျာဗားမှချွင်းချက်အားလုံးသည် Exception
၏ကလေးများဖြစ်သင့်သည် Throwable
၏ကလေးတစ် ဦး ဖြစ်သည် အတန်းအစား။
Exception
၏အဓိက subclass နှစ်ခု အတန်းအစားသည် _ _ _ _ နှင့် RuntimeException
။
IOException
၏နောက်ထပ်ကလေးအတန်း အတန်းသည် Throwable
အတန်းအစား။ သို့သော်အမှားများမှာခြွင်းချက်များနှင့်ကွဲပြားသည်။
အမှားများက JVM ကွပ်မျက်ခံရစဉ်အတွင်းကြုံတွေ့ရနိုင်သည့်ပြproblemsနာများကိုဖော်ပြသည်။ ဤပြproblemsနာများသည်များသောအားဖြင့်ဝေဖန်။ မရနိုင်သောအရာများဖြစ်သည်။ Memory ယိုစိမ့်မှုနှင့်စာကြည့်တိုက်သဟဇာတမဖြစ်ခြင်းပြprogramsနာများသည်ပရိုဂရမ်များတွင်အမှားအယွင်းများဖြစ်လေ့ရှိသည်။
Error
နှင့် StackOverflowError
Java Errors ၏ဥပမာနှစ်ခုဖြစ်သည်။
Java ချွင်းချက်များကိုအဓိကအမျိုးအစားနှစ်မျိုးခွဲခြားနိုင်သည်။ check လုပ်ထား နှင့် မစစ်ဆေးပါ ခြွင်းချက်။
Check ခြွင်းချက်များမှာ compile မပြုမီ program တွင်ကိုင်တွယ်ရန်လိုအပ်သောခြွင်းချက်များဖြစ်သည်။ ဤချွင်းချက်များကိုမကိုင်တွယ်ပါက၊ ပရိုဂရမ်ကို Java compiler ကပြုစုမည်မဟုတ်ပါ။ ထို့ကြောင့်၎င်းကို compile-time ခြွင်းချက်များဟုလည်းခေါ်သည်။ OutOfMemoryError
check လုပ်ထားခြွင်းချက်ကောင်းသောဥပမာဖြစ်ကြသည်။
ပရိုဂရမ်ကိုပြုစုသည့်အခါမှတ်သားထားခြင်းမရှိသောခြွင်းချက်များမှာ compiler ကလျစ်လျူရှုသောချွင်းချက်များဖြစ်သည်။ ကျွန်ုပ်တို့သည်ဤအစီအစဉ်တွင်ခြွင်းချက်များကိုကိုင်တွယ်သည်ဖြစ်စေ၊ မရှိသည်ဖြစ်စေအစီအစဉ်ကိုပြုစုသောအခါအရေးမကြီးပါ။ ဤချွင်းချက်များတွင်ခြွင်းချက်အားကိုင်တွယ်ခြင်းမပြုလုပ်သောကြောင့်ကျွန်ုပ်တို့၏အစီအစဉ်သည် IOExceptions
သို့ပြေးနိုင်သည် program ကိုရပ်စဲကြောင်းရလဒ်။
RuntimeExceptions
တိုးချဲ့သောအတန်းအားလုံး အတန်းသည်စစ်ဆေးခြင်းမရှိသောခြွင်းချက်များဖြစ်သည်။ ထိုကဲ့သို့သောအတန်းဥပမာနှစ်ခုကို RuntimeException
နှင့် NullPointerException
။
Java တွင် __ _ _ _ အသုံးများသောနည်းစနစ်အနည်းငယ်ကိုကျွန်ုပ်တို့သွားပါမည် အတန်း
ArrayIndexOutOfBoundsException
: ဖြစ်ပွားခဲ့သောချွင်းချက်နှင့်ပတ်သက်သည့်အသေးစိတ်အချက်အလက်များပါသည့်စာတစ်စောင်ကိုပြန်ပို့သည်။Exception
: ဖြစ်ပျက်ခဲ့သည့်ချွင်းချက်၏ stack သဲလွန်စကိုပြန်ပို့သည်။getMessage
: အတန်းအမည်နှင့်စာကိုပြန်ပို့သည့် printStackTrace
နည်းလမ်း။ဂျာဗားတွင်ခြွင်းချက်များကိုမည်သို့ကိုင်တွယ်နိုင်သည်ကိုကြည့်ကြပါစို့။
ခြွင်းချက်များကိုဖမ်းယူပြီး၎င်းတို့ကိုစနစ်တကျကိုင်တွယ်နိုင်သည် ကြိုးစားပါ ဂျာဗားတွင်ပိတ်ဆို့ခြင်း
ဤ syntax တွင်ခြွင်းချက်တစ်ခုကိုချပစ်ရန်အလွန်လွယ်ကူသောကုဒ်၏အစိတ်အပိုင်းကို try block အတွင်း၌နေရာချပြီး catch block / blocks သည်ပစ်ထားသောခြွင်းချက် / ခြွင်းချက်များကိုဖမ်းယူပြီး၎င်းတို့အားကျွန်ုပ်တို့ထောက်ပံ့ထားသောယုတ္တိဗေဒအရကိုင်တွယ်သည်။
try-catch block ၏အခြေခံ syntax သည်အောက်ပါအတိုင်းဖြစ်သည်။
toString
ဤချဉ်းကပ်မှုဖြင့်ပရိုဂရမ်သည်ခြွင်းချက်တစ်ခုကိုပရိုဂရမ်မှပစ်ချသောအခါလုပ်ဆောင်မှုကိုရပ်တန့်မသွားဘဲ၎င်းကိုလျောက်ပတ်စွာကိုင်တွယ်သည်။
getMessage
ကျွန်ုပ်တို့မည်သို့ကိုင်တွယ်ရမည်ကိုကျွန်ုပ်တို့တွေ့ရမည် try {
အားဖြင့်ပစ်ချ Java ပရိုဂရမ်တွင်လူတန်းစား။
//exception-prone code } catch(Exception e) {
//error handling logic }
ဥပမာ -
IOExceptions
ဤတွင်ကျွန်ုပ်တို့သည် FileReader
ကိုကိုင်တွယ်ရန် catch block တစ်ခုကိုအသုံးပြုခဲ့သည် import java.io.FileReader; public class TryCatchBlockExample {
instantiating သောအခါပစ်ချ အတန်းအစားနှင့်
public static void main(String[] args) {
try {
FileReader file = new FileReader('source.txt');
file.read();
}
catch(Exception e) {
e.printStackTrace();
}
} } FileNotFoundException
FileReader
အားဖြင့်ပစ်ချ IOException
၏နည်းလမ်း အတန်းအစား။
ဤခြွင်းချက်နှစ်ခုလုံးသည် read()
၏ကလေးများဖြစ်သည် အတန်းအစား။
တစ်ခုတည်းသော try ထုတ်ပြန်ချက်အတွင်းရှိကုဒ်ကြောင့်ဖြစ်ပေါ်လာသောအမှားအယွင်းအမျိုးမျိုးကိုဖမ်းရန်အတွက် catch ထုတ်ပြန်ချက်များစွာကိုလည်းကျွန်ုပ်တို့အသုံးပြုနိုင်သည်။ ပြီးခဲ့သည့်ဥပမာအနေဖြင့် FileReader
ကိုဖမ်းရန် catch block တစ်ခုကိုသုံးနိုင်သည် နှင့် Exception
အတွက်နောက်ထပ်ဖမ်းပိတ်ပင်တားဆီးမှု အောက်ကကုဒ်နံပါတ်ကပြထားတဲ့အတိုင်း -
FileNotFoundException
အကယ်၍ ပစ်ချသည့်ချွင်းချက်သည်ပထမဖမ်းခြင်းဖော်ပြချက်မှကိုင်တွယ်သောချွင်းချက်နှင့်ကိုက်ညီပါက၎င်းသည်ပထမဆုံးဖမ်းခြင်းကြေညာချက်အတွင်းရှိယုတ္တိဗေဒဖြင့်ကိုင်တွယ်သည်။
ခြွင်းချက်များနှင့်မကိုက်ညီပါက၎င်းသည်ဒုတိယဖမ်းယူချက်သို့ကူးပြောင်းသွားသည်။ catch ထုတ်ပြန်ကြေငြာချက်နှစ်ခုထက်ပိုပါကဤအမျိုးအစားသည်ဖမ်းယူသော type ကြေငြာချက်သို့ရောက်သည့်တိုင်အောင်ဤလုပ်ငန်းစဉ်သည်ဆက်လက်လုပ်ဆောင်မည်။
IOException
ကတည်းကကတည်းက import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchBlockExample {
၏အမျိုးအစားခွဲတစ်ခု၊
public static void main(String[] args) {
try {
FileReader file = new FileReader('source.txt');
file.read();
file.close();
}
catch(FileNotFoundException e) {
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
} } FileNotFoundException
ကိုဖမ်းရန်ဒုတိယဖမ်းချက်ထုတ်ပြန်ကြေငြာချက်ကိုသုံးသည် အလုပ်မလုပ်ပါ ၎င်းကိုပထမဆုံးဖမ်းယူသည့်ဖော်ပြချက်ကကိုင်တွယ်မည်ဖြစ်ပြီးဒုတိယအကြိမ်ထုတ်ပြန်ချက်ကိုဘယ်တော့မျှရောက်လိမ့်မည်မဟုတ်ပါ။
ကျွန်တော်တစ် ဦး ကိုအသုံးပြုတဲ့အခါ ကြိုးစားပါ ကျွန်ုပ်တို့၏ပရိုဂရမ်တွင်ခြွင်းချက်များကိုဖမ်းရန်ပိတ်ပင်ထားသည်၊ ခြွင်းချက်တစ်ခုကိုဖမ်းမိသည်ဖြစ်စေ၊ မရှိသည်ဖြစ်စေသိထားသည့်အတိုင်းယုတ္တိဗေဒအချို့ကိုကျွန်ုပ်တို့အကောင်အထည်ဖော်လိုသည်။ ထိုကဲ့သို့သောကိစ္စများတွင်ကျွန်ုပ်တို့သည် a ကိုသုံးနိုင်သည် ကြိုးစား - ဖမ်း - နောက်ဆုံး ရုံတစ် ဦး ၏ပိတ်ပင်တားဆီးမှု ကြိုးစားပါ ပိတ်ပင်တားဆီးမှု။
ထို့နောက် IOException
အတွင်းရှိကုဒ်ကို ကြေညာချက်တစ်ခုခြွင်းချက်ဖြစ်ပေါ်ဖြစ်စေမအကောင်အထည်ဖော်နေသည်။ FileNotFoundException
ကြေငြာချက်သည် try-catch-акырыပိတ်ပင်တားဆီးမှု၏အဆုံးတွင်အမြဲရောက်သင့်သည်။
ဥပမာအားဖြင့်၊ _ _ _ _ _ ဖိုင်တစ်ခုကိုဖတ်ရန် class သည်၎င်းသည်ခြွင်းချက်တစ်ခုဖြစ်ပေါ်သည်ဖြစ်စေ၊ မပြုလုပ်သည်ဖြစ်စေ processing ၏အဆုံးမှာဖွင့်ထားသောဖိုင်ကိုပိတ်ရန်မရှိမဖြစ်လိုအပ်သည်။ ၎င်းကိုသေချာစေရန်ဖိုင်ကိုပိတ်ပစ်ရန် finally
ထဲတွင်နေရာချနိုင်သည် ကြေညာချက်
finally
သို့သော်၊ အထက်ပါကုဒ်ကိုသင်ကြိုးစားရန်ကြိုးစားလျှင်၊ _ _ _ _ _ သည်မကိုင်တွယ်သောကြောင့်ကုဒ်ကိုပြုစုမည်မဟုတ်ပါ။ ဘာကြောင့်လဲဆိုတော့ FileReader
finally
၏နည်းလမ်း အတန်းကိုလည်းပစ်နိုင်သည် import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
။ ဒါကြောင့်ဒီအပိုင်းကိုအောက်ပါ try block တစ်ခုထဲမှာထားရမယ်။
public static void main(String[] args) {
FileReader file = null;
try {
file = new FileReader('source.txt');
file.read();
}
catch(FileNotFoundException e) {
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
finally {
file.close();
}
} }
IOException
close()
ကို အသုံးပြု၍ အမှားများကိုကိုင်တွယ် ဂျာဗားရှိသော့ချက်စာလုံးသည်ရိုးရှင်းပါသည်။ တကယ်တော့၊ ဒီချဉ်းကပ်မှုမှာသင်ခြွင်းချက်ကိုသူတွေ့တဲ့နေရာမှာမကိုင်တွယ်ပါဘူး။ အဲဒီအစား၊ ကျွန်ုပ်တို့သည်လက်ရှိနည်းလမ်းမှချွင်းချက်အားလက်ရှိနည်းလမ်းဟုခေါ်သည့်နည်းလမ်းသို့လွှင့်ပစ်သည်။ ထို့နောက်အမှားကိုကိုင်တွယ်ခြင်းသည်ပြင်ပနည်းလမ်း၏တာဝန်ဖြစ်လာသည်။
ချွင်းချက်တစ်ခုကိုနည်းလမ်းတစ်ခုမှဖယ်ထုတ်ရန်ဤနည်းလမ်းသည်ထည့်သွင်းစဉ်းစားထားသောချွင်းချက်ကိုပစ်လိုက်နိုင်ကြောင်းကြေငြာရန်သာလိုသည်။ ငါတို့ဘယ်လိုကိုင်တွယ်နိုင်သည်ကိုကြည့်ကြစို့ FileReader
IOExceptions
အားဖြင့်ပစ်ချ ဒီချဉ်းကပ်နည်းကိုအသုံးပြုပြီးလူတန်းစား။
ဥပမာ -
import java.io.FileNotFoundException; import java.io.FileReader; import java.io.IOException; public class TryCatchFinallyBlockExample {
public static void main(String[] args) {
FileReader file = null;
try {
file = new FileReader('source.txt');
file.read();
}
catch(FileNotFoundException e) {
e.printStackTrace();
}
catch(IOException e) {
e.printStackTrace();
}
finally {
try {
file.close();
}
catch(IOException e) {
e.printStackTrace();
}
}
} }
ဤစာရင်းရှိအခြားနည်းလမ်းများနှင့်မတူဘဲ throws
အမှားအယွင်းများကိုင်တွယ်ရန်သော့ချက်စာလုံးကိုမသုံးပါ။ သို့သော်လူအများစုက IOExceptions
ကိုရှုပ်ထွေးစေသည် _ + _ | နှင့်သော့ချက်စာလုံး သော့ချက်စာလုံးကိုဒီမှာကြည့်ရတာအကောင်းဆုံးဖြစ်မယ်လို့ကျွန်တော်တို့ထင်တယ်
FileReader
သော့ချက်စာလုံးသည်ခြွင်းချက်တခုကိုအတိအလင်းဖော်ပြရန်အသုံးပြုသည်။ အသစ်တီထွင်ထားသောခြွင်းချက်တစ်ခုသို့မဟုတ်နည်းလမ်းအတွင်း၌ဖမ်းမိသောချွင်းချက်တစ်ခုကိုကျွန်ုပ်တို့ပစ်ချနိုင်သည်။
import java.io.FileReader; import java.io.IOException; public class ThrowsExample {
public void readFile throws IOException {
FileReader file = new FileReader('source.txt');
file.read();
file.close();
} }
built-in Java ချွင်းချက်များအသုံးပြုခြင်းအပြင်သင်သည်သင်၏ကိုယ်ပိုင်ချွင်းချက်များကိုသတ်မှတ်နိုင်သည်။ သူတို့ကိုသင် check လုပ်ထားသည့် (သို့) မစစ်ဆေးရသေးသောခြွင်းချက်များအဖြစ်သတ်မှတ်နိုင်သည်။ အသစ်ပြန်လည်စစ်ဆေးထားသောချွင်းချက်တစ်ခုကိုဖန်တီးရန်သင့်ချွင်းချက်အသစ်သည် throw
ကိုတိုးချဲ့သင့်သည် အတန်းအစား။
ဖန်တီးရန် မအောင်မြင်ဘူး ခြွင်းချက်, throw
တိုးချဲ့ပါ အတန်းအစား။
အောက်ဖော်ပြပါကုဒ်ဥပမာတွင်ကျွန်ုပ်တို့သည်အသုံးပြုသူသတ်မှတ်ထားသောစစ်ဆေးထားသောချွင်းချက်ကိုဖန်တီးထားသည်။
throws
ယခုကျွန်ုပ်တို့သည်ကျွန်ုပ်တို့၏ logic logic အတွင်းရှိအထက်ပါခြွင်းချက်ကိုဤကဲ့သို့ပြုလုပ်နိုင်ပါပြီ။
throw
public class ThrowExample {
ကိုသုံးပြီး string တစ်ခုရဲ့အရှည်ကိုစစ်ဆေးမယ်ဆိုရင် အတန်းအစားသည်၎င်းကိုပစ်ချလိမ့်မည်။ _ + _ | string ကိုအရှည်နိမ့်ဆုံးအရှည်အောက်သို့မဟုတ်အများဆုံးအရှည်အထက်လျှင်။
public void invalidate(int amount) throws Exception {
if (amount < 500) {
throw new Exception('Amount not sufficient');
}
} }
Exception
အထက်ပါ code အတိုအထွာကို run သောအခါ၎င်းသည် RuntimeException
ကိုပစ်လိမ့်မည် ကျနော်တို့အောက်ပါ output ကိုရရှိပါလိမ့်မယ်:
public class InvalidLengthException extends Exception {
private int length;
private String message;
public InvalidLengthException(int length, String message) {
this.length=length;
this.message=message;
}
public int getAmount() {
return this.length;
}
public String getMessage() {
return this.message;
} }
ဤသင်ခန်းစာတွင် Java Exceptions ကိုအတိုချုပ်နှင့်အတိုချုပ်မိတ်ဆက်ပေးခဲ့သည်။ သင်သည်သင်၏ Java program တွင်ခြွင်းချက်များနှင့်မည်သို့ကိုင်တွယ်ရမည်ကိုကောင်းစွာနားလည်ရန်မျှော်လင့်ပါသည်။