Java ချွင်းချက်များနှင့်၎င်းတို့အားမည်သို့ကိုင်တွယ်ရမည်နည်း

Java developer တစ်ယောက်အနေဖြင့်၊ သင်သည် Java ချွင်းချက်များနှင့်ခြွင်းချက်များကိုင်တွယ်ခြင်းဆိုင်ရာဗဟုသုတကောင်းများရှိသင့်သည်။

ဤသင်ခန်းစာသည် Java ပရိုဂရမ်များနှင့်အလုပ်လုပ်စဉ်ပရိုဂရမ်မာအားလုံးရှိရမည်အခြေခံဗဟုသုတကိုပေးသည်။ စတင်ရန် Java Exception များအတိအကျကိုနားလည်ခြင်းဖြင့်စတင်ကြပါစို့။



Java Exception များ

Java ပရိုဂရမ်တစ်ခုသည်ပြexecutionနာများဖြစ်ပွားနိုင်ပြီး၎င်းပရိုဂရမ်သည် ၄ ​​င်း၏လုပ်ဆောင်မှုအတွင်းရုတ်တရက်ရပ်တန့်သွားစေနိုင်သည်။ ဤပြproblemsနာများကိုခြွင်းချက်ဟုခေါ်သည်။


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

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




ကျွန်ုပ်တို့သည်အဘယ်ကြောင့် Exception Handling လိုအပ်သည်

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

အသုံးပြုသူထည့်သွင်းမှုကိုလက်ခံသောပရိုဂရမ်များသည်အသုံးပြုသူမှမမှန်ကန်သောထည့်သွင်းမှုကြောင့်ချွင်းချက်များသို့ကျရောက်နိုင်သည်။ ထို့အပြင်ပြင်ပဖိုင်များကိုဖတ်ခြင်းသည်ပရိုဂရမ်မာ၏ဗဟုသုတမရှိပဲ၎င်းတို့အားပြင်ပအရင်းအမြစ်တစ်ခုမှရွှေ့ပြောင်းခြင်း၊

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



Java ချွင်းချက်များ၏အဆင့်ဆင့်

ဂျာဗားမှချွင်းချက်အားလုံးသည် Exception ၏ကလေးများဖြစ်သင့်သည် Throwable ၏ကလေးတစ် ဦး ဖြစ်သည် အတန်းအစား။


Exception ၏အဓိက subclass နှစ်ခု အတန်းအစားသည် _ _ _ _ နှင့် RuntimeException



အမှား vs ခြွင်းချက်

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 တွင် __ _ _ _ အသုံးများသောနည်းစနစ်အနည်းငယ်ကိုကျွန်ုပ်တို့သွားပါမည် အတန်း

  1. ArrayIndexOutOfBoundsException: ဖြစ်ပွားခဲ့သောချွင်းချက်နှင့်ပတ်သက်သည့်အသေးစိတ်အချက်အလက်များပါသည့်စာတစ်စောင်ကိုပြန်ပို့သည်။
  2. Exception: ဖြစ်ပျက်ခဲ့သည့်ချွင်းချက်၏ stack သဲလွန်စကိုပြန်ပို့သည်။
  3. getMessage: အတန်းအမည်နှင့်စာကိုပြန်ပို့သည့် printStackTrace နည်းလမ်း။


ခြွင်းချက်များကိုင်တွယ်နည်း

ဂျာဗားတွင်ခြွင်းချက်များကိုမည်သို့ကိုင်တွယ်နိုင်သည်ကိုကြည့်ကြပါစို့။

ကြိုးစားပါ

ခြွင်းချက်များကိုဖမ်းယူပြီး၎င်းတို့ကိုစနစ်တကျကိုင်တွယ်နိုင်သည် ကြိုးစားပါ ဂျာဗားတွင်ပိတ်ဆို့ခြင်း

ဤ syntax တွင်ခြွင်းချက်တစ်ခုကိုချပစ်ရန်အလွန်လွယ်ကူသောကုဒ်၏အစိတ်အပိုင်းကို try block အတွင်း၌နေရာချပြီး catch block / blocks သည်ပစ်ထားသောခြွင်းချက် / ခြွင်းချက်များကိုဖမ်းယူပြီး၎င်းတို့အားကျွန်ုပ်တို့ထောက်ပံ့ထားသောယုတ္တိဗေဒအရကိုင်တွယ်သည်။


try-catch block ၏အခြေခံ syntax သည်အောက်ပါအတိုင်းဖြစ်သည်။

toString

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

getMessage ကျွန်ုပ်တို့မည်သို့ကိုင်တွယ်ရမည်ကိုကျွန်ုပ်တို့တွေ့ရမည် try {
//exception-prone code } catch(Exception e) {
//error handling logic }
အားဖြင့်ပစ်ချ Java ပရိုဂရမ်တွင်လူတန်းစား။

ဥပမာ -

IOExceptions

ဤတွင်ကျွန်ုပ်တို့သည် FileReader ကိုကိုင်တွယ်ရန် catch block တစ်ခုကိုအသုံးပြုခဲ့သည် import java.io.FileReader; public class TryCatchBlockExample {
public static void main(String[] args) {

try {

FileReader file = new FileReader('source.txt');

file.read();
}
catch(Exception e) {

e.printStackTrace();
}
} }
instantiating သောအခါပစ်ချ အတန်းအစားနှင့် 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 ကိုဖမ်းရန်ဒုတိယဖမ်းချက်ထုတ်ပြန်ကြေငြာချက်ကိုသုံးသည် အလုပ်မလုပ်ပါ ၎င်းကိုပထမဆုံးဖမ်းယူသည့်ဖော်ပြချက်ကကိုင်တွယ်မည်ဖြစ်ပြီးဒုတိယအကြိမ်ထုတ်ပြန်ချက်ကိုဘယ်တော့မျှရောက်လိမ့်မည်မဟုတ်ပါ။

မှတ်စု:အနည်းဆုံး catch statement တစ်ခုကို try statement နှင့်အသုံးပြုရန်မလိုအပ်ပါ။

နောက်ဆုံးတော့

ကျွန်တော်တစ် ဦး ကိုအသုံးပြုတဲ့အခါ ကြိုးစားပါ ကျွန်ုပ်တို့၏ပရိုဂရမ်တွင်ခြွင်းချက်များကိုဖမ်းရန်ပိတ်ပင်ထားသည်၊ ခြွင်းချက်တစ်ခုကိုဖမ်းမိသည်ဖြစ်စေ၊ မရှိသည်ဖြစ်စေသိထားသည့်အတိုင်းယုတ္တိဗေဒအချို့ကိုကျွန်ုပ်တို့အကောင်အထည်ဖော်လိုသည်။ ထိုကဲ့သို့သောကိစ္စများတွင်ကျွန်ုပ်တို့သည် 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 {
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();
}
} }
။ ဒါကြောင့်ဒီအပိုင်းကိုအောက်ပါ try block တစ်ခုထဲမှာထားရမယ်။

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 {
public void invalidate(int amount) throws Exception {
if (amount < 500) {

throw new Exception('Amount not sufficient');
}
} }
ကိုသုံးပြီး string တစ်ခုရဲ့အရှည်ကိုစစ်ဆေးမယ်ဆိုရင် အတန်းအစားသည်၎င်းကိုပစ်ချလိမ့်မည်။ _ + _ | string ကိုအရှည်နိမ့်ဆုံးအရှည်အောက်သို့မဟုတ်အများဆုံးအရှည်အထက်လျှင်။

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 တွင်ခြွင်းချက်များနှင့်မည်သို့ကိုင်တွယ်ရမည်ကိုကောင်းစွာနားလည်ရန်မျှော်လင့်ပါသည်။

စိတ်ဝင်စားစရာဆောင်းပါးများ