Paano Pangasiwaan ang Mga Pagbubukod ng Java sa Tamang Paraan

IllegalArgumentException
Upang mahuli ang pagbubukod na ito, kailangan mong pumunta sa kung saan
someMethod()
ay tinawag at ginagamit ang try-catch block :
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Lahat sa loob ng subukan mo ang block ay papatayin sa pagkakasunud-sunod hanggang sa ang isang pagbubukod ay itinapon. Kaagad na itinapon ang isang pagbubukod, lahat ng mga kasunod na pahayag ay nalaktawan at ang lohika ng application ay agad na tumalon sa mahuli harangan
 
Sa aming halimbawa, ipinasok namin ang try block at agad na tumatawag
someMethod()
. Dahil ang 200 ay hindi nasa pagitan ng 0 at 100, an
IllegalArgumentException
ay itinapon. Agad nitong tinatapos ang pagpapatupad ng
someMethod()
, nilaktawan ang natitirang lohika sa block ng pagsubok (
someOtherMethod()
ay hindi kailanman tinawag), at ipinagpatuloy ang pagpapatupad sa loob ng catch block.
 
Ano ang mangyayari kung tumawag kami
someMethod(50)
sa halip Ang
IllegalArgumentException
hindi kailanman itapon.
someMethod()
naisakatuparan bilang normal. Isinasagawa ang try block bilang normal, pagtawag
someOtherMethod()
kapag ang ilangMethod () ay nakumpleto. Kailan
someOtherMethod()
nagtatapos, ang catch block ay lalaktawan at
callingMethod()
magpapatuloy.
 
Tandaan na maaari kang magkaroon ng maraming mga bloke ng catch bawat try block:
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 } catch (NullPointerException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Tandaan din na isang opsyonal sa wakas mayroon ding block:
public void method() {  
 try {  
 // ...  
 } catch (Exception e) {  
 // ...  
 } finally {  
 // ...  
 }  
}
Ang code sa loob ng isang wakas na bloke ay palagi pinaandar kahit ano. Kung mayroon kang isang pahayag sa pagbabalik sa try block, ang wakas na block ay naisakatuparan bago bumalik sa labas ng pamamaraan. Kung magtapon ka ng isa pang pagbubukod sa catch block, ang wakas na bloke ay naisakatuparan bago itapon ang pagbubukod.
 
Dapat mong gamitin ang wakas na pag-block kapag mayroon kang mga bagay na kailangang linisin bago magtapos ang pamamaraan. Halimbawa, kung binuksan mo ang isang file sa try block at sa paglaon ay nagtapon ng isang pagbubukod, hinahayaan ka ng wakas na block na isara ang file bago iwanan ang pamamaraan.
 
Tandaan na maaari kang magkaroon ng isang wakas na pag-block nang walang catch block:
public void method() {  
 try {  
 // ...  
 } finally {  
 // ...  
 }  
}
Hinahayaan ka nitong gumawa ng anumang kinakailangang paglilinis habang pinapayagan ang mga itinapon na pagbubukod upang maipalaganap ang stack ng pamamaraan ng pagtawag (ibig sabihin hindi mo nais na hawakan ang pagbubukod dito ngunit kailangan mo pa ring linisin muna).
 
Sinuri kumpara sa Hindi Naseksyong Mga Pagbubukod sa Java
Hindi tulad ng karamihan sa mga wika, nakikilala ang Java sa pagitan naka-check na mga pagbubukod at walang check na mga pagbubukod (hal. Ang C # ay may mga hindi naka-check na pagbubukod). Isang naka-check na pagbubukod dapat mahuli sa pamamaraan kung saan itinapon ang pagbubukod o kung hindi ang code ay makakaipon.
 
Upang lumikha ng isang may check na pagbubukod, magpahaba mula sa
Exception
. Upang lumikha ng isang walang check na pagbubukod, magpahaba mula sa
RuntimeException
.
 
Ang anumang pamamaraan na nagtatapon ng isang may check na pagbubukod ay dapat na magpahiwatig nito sa lagda ng pamamaraan gamit ang nagtatapon keyword. Dahil ang built-in na Java
IOException
ay isang may check na pagbubukod, ang sumusunod na code ay hindi makakaipon:
public void wontCompile() {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Dapat mo munang ideklara na nagtatapon ito ng isang naka-check na pagbubukod:
public void willCompile() throws IOException {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Tandaan na ang isang pamamaraan ay maaaring ideklara bilang pagkahagis ng isang pagbubukod ngunit hindi talaga magtapon ng isang pagbubukod. Kahit na, ang pagbubukod ay kakailanganin pa ring mahuli kung hindi man ang code ay hindi makakaipon.
 
Kailan mo dapat gamitin ang mga may eksepsyon na naka-check o hindi nasuri?
 
Ang opisyal na dokumentasyon ng Java ay mayroong a pahina sa katanungang ito . Ito ang nagbubuod ng pagkakaiba sa isang maikli na tuntunin ng hinlalaki: 'Kung ang isang kliyente ay maaaring asahan na makabawi mula sa isang pagbubukod, gawin itong isang may check na pagbubukod. Kung ang isang kliyente ay hindi maaaring gumawa ng anumang bagay upang mabawi mula sa pagbubukod, gawin itong isang walang check na pagbubukod. '
 
Ngunit ang patnubay na ito ay maaaring luma na. Sa isang banda, ang mga naka-check na pagbubukod ay nagreresulta sa mas matatag na code. Sa kabilang banda, walang ibang wika ang nag-check ng mga pagbubukod sa parehong pamamaraan tulad ng Java, na nagpapakita ng dalawang bagay: una, ang tampok ay hindi sapat na kapaki-pakinabang para sa iba pang mga wika upang magnakaw ito, at dalawa, maaari mong ganap na mabuhay nang wala sila. Dagdag pa, ang mga naka-check na pagbubukod ay hindi maglaro ng maayos sa mga expression ng lambda na ipinakilala sa Java 8.
 
Mga Alituntunin para sa Paggamit ng Mga Maliban sa Java
 
Ang mga pagbubukod ay kapaki-pakinabang ngunit madaling hindi nagamit at naabuso. Narito ang ilang mga tip at pinakamahusay na kasanayan upang matulungan kang maiwasan na gumawa ng gulo sa kanila.
 
 
  Mas gusto ang mga tukoy na pagbubukod sa pangkalahatang mga pagbubukod. Gumamit ng NumberFormatException higit sa IllegalArgumentException kung posible, kung hindi man ay gumamit ng IllegalArgumentException higit sa RuntimeException kung maaari
 
  Huwag kailanman mahuli Throwable ! Ang Exception talagang pinalawak ang klase Throwable , at ang catch block ay talagang gumagana sa Throwable o anumang klase na umaabot sa Throwable. Gayunpaman, ang Error umaabot din ang klase Throwable , at hindi mo nais na mahuli ang isang Error dahil Error s nagpapahiwatig ng mga seryosong hindi mababawi na isyu.
 
  Huwag kailanman mahuli Exception ! InterruptedException umaabot Exception , kaya't anumang bloke na nakakakuha Exception mahuhuli din ang InterruptedException , at iyon ay isang napakahalagang pagbubukod na hindi mo nais na makialam (lalo na sa mga multi-threaded na mga application) maliban kung alam mo kung ano ang iyong ginagawa. Kung hindi mo alam kung aling pagbubukod ang mahuli sa halip, isaalang-alang na huwag mahuli ang anumang bagay.
 
  Gumamit ng mga naglalarawang mensahe upang magaan ang pag-debug. Kapag nagtapon ka ng isang pagbubukod, maaari kang magbigay ng isang String mensahe bilang isang pagtatalo. Maaaring ma-access ang mensaheng ito sa catch block gamit ang Exception.getMessage() pamamaraan, ngunit kung ang pagbubukod ay hindi kailanman nahuli, lilitaw din ang mensahe bilang bahagi ng bakas ng stack.
 
  Subukang huwag mahuli at balewalain ang mga pagbubukod. Upang maiikot ang abala ng mga naka-check na pagbubukod, maraming mga newbie at tamad na programmer ang magse-set up ng isang block block ngunit iwanan itong walang laman. Masama! Palaging hawakan ito nang kaaya-aya, ngunit kung hindi mo magawa, kahit papaano mai-print ang isang bakas ng stack upang malaman mo ang pagbubukod ay itinapon. Magagawa mo ito gamit ang Exception.printStackTrace() pamamaraan
 
  Mag-ingat sa labis na paggamit ng mga pagbubukod. Kapag mayroon kang martilyo, ang lahat ay mukhang kuko. Kapag kauna-unahang natutunan ang tungkol sa mga pagbubukod, maaari mong pakiramdam na obligadong gawing isang pagbubukod ang lahat ... sa puntong ang karamihan sa daloy ng kontrol ng iyong application ay bumaba sa paghawak ng pagbubukod. Tandaan, ang mga pagbubukod ay inilaan para sa 'pambihirang' paglitaw!
 
 
Ngayon dapat kang sapat na komportable kasama ang mga pagbubukod upang maunawaan kung ano ang mga ito, kung bakit sila ginagamit, at kung paano isasama ang mga ito sa iyong sariling code. Kung hindi mo lubos na nauunawaan ang konsepto, okay lang! Medyo natagalan ako para ito ay 'mag-click' sa aking ulo, kaya huwag mong pakiramdam na kailangan mo itong bilisan. Huwag kang mag-madali.
 
  Mayroon bang mga katanungan? May alam ka bang ibang mga tip na nauugnay sa pagbubukod na napalampas ko? Ibahagi ang mga ito sa mga komento sa ibaba!  
  Magbahagi    Magbahagi      Mag-tweet      Email      Paano Lumikha ng isang Data-Flow Diagram upang Mailarawan ang Data ng Anumang Project  
Ang mga diagram ng daloy ng data (DFD) ng anumang proseso ay makakatulong sa iyo na maunawaan kung paano dumadaloy ang data mula sa mapagkukunan patungo sa patutunguhan. Narito kung paano ito likhain!
Basahin Susunod   Mga Kaugnay na Paksa  
 
Programming
 
Java
 
  Tungkol sa May-akda   Si Joel lee(1524 Mga Artikulo Na-publish)            
Si Joel Lee ay ang Editor in Chief ng MakeUseOf mula pa noong 2018. Mayroon siyang B.S. sa Computer Science at higit sa siyam na taong propesyonal na karanasan sa pagsusulat at pag-edit.
kung paano patakbuhin ang mga bintana ng mga programa sa Chromebook
Higit pa Mula kay Joel Lee
Mag-subscribe sa aming newsletter
 
Sumali sa aming newsletter para sa mga tip sa tech, pagsusuri, libreng ebook, at eksklusibong deal!
Mag-click dito upang mag-subscribe