Ang mga pagbubukod sa Java ay mga kundisyon na imposible para sa computer na magpatuloy sa pagpapatupad ng code ng isang programa ng Java at pagkatapos ay mag-crash ang application. Nagmula ang mga ito mula sa loob ng Java source code, mula sa mga nag-develop alinman sa hindi pagtupad upang ayusin ang isang bug o pagkabigo na asahan ang mga problema na maaaring magmula sa kapaligiran kung saan tumatakbo ang kanilang programa, at hindi mula sa iyong mga aksyon.
Mga Kakaibang Kaganapan
Ang mga programa ay maayos na hanay ng mga sunud-sunod na tagubilin na nagsasabi sa isang computer nang eksakto kung paano gumawa ng isang bagay. Ang mga pambihirang kaganapan, o pagbubukod, ay nangyayari kapag may nangyari habang tumatakbo ang isang programa na nakagagambala sa mga tagubiling iyon. Pareho sila sa iyo na sumusunod sa mga tagubilin para sa pagtitipon ng isang desk para sa iyong tanggapan, upang malaman na ang bahagi na sinasabi sa iyo ng mga tagubilin na gamitin ay hindi dumating sa pakete.
Nakakahabol ng Mga Pagbubukod
Maaaring pigilan ng mga developer ng Java ang mga pagbubukod mula sa pag-crash ng kanilang software sa pamamagitan ng pagsasama ng code upang mahuli ang mga pagbubukod kapag nangyari ito. Ang mga pahayag na ito ay mabisang sinasabi sa software na maging bantayan ng mga pagbubukod sa mga tukoy na punto sa pagpapatupad ng application. Kung may isang pagbubukod na nagaganap kung saan hinihintay ito ng isang pahayag ng catch, pagkatapos ay isasagawa ng software ang code sa loob ng pahayag ng catch. Pinapayagan nito ang mga developer ng Java na makayanan ang kanilang software na may mga pagbubukod na maaaring lumabas at magpatuloy sa pagpapatupad sa halip na pag-crash ng isang mensahe ng error.
Exception Object
Ang pagharap sa mga pagbubukod ay hindi limitado sa pagrerehistro lamang ng katotohanang may naganap na pagbubukod. Kapag ang mga aplikasyon ng Java ay nagtapon ng isang pagbubukod, ang Java Virtual Machine ay bumubuo ng isang bagay na pagbubukod na naglalaman ng impormasyon tungkol sa mismong pagbubukod. Maaaring magsama ang mga developer ng code sa ilalim ng mga pahayag ng catch upang suriin ang likas na katangian ng pagbubukod, at upang tumugon sa iba't ibang paraan depende sa mismong pagbubukod. Pinapayagan nito ang mga programmer na magtangka upang malutas ang pagbubukod nang hindi mo nalalaman o gawin ang pagpapakita ng mga mensahe ng application na nagdedetalye sa likas na problema nang hindi nag-crash.
Paghahanda para sa Mga Exception
Binibigyan ng Java ang mga developer ng kakayahang mahuli at makaya ang mga pagbubukod, ngunit ang mga programmer ay hindi maaaring subukang isaalang-alang ang bawat pagbubukod na maaaring maganap sa loob ng isang programa. Mahusay na kasanayan sa programa ang hinihiling sa mga developer na asahan ang mga problema na mapagkukunan ng panlabas sa kanilang source code na maaaring maging sanhi para sa kanilang software, tulad ng isang server na hindi wastong pagtugon sa isang koneksyon ng socket o sinusubukan mong mag-import ng nasirang data mula sa isa sa iyong mga file. Gayunpaman, ang mahinang source code na nagpapakilala sa mga error sa lohika o iba pang mga panloob na bug ay maaari ring makabuo ng mga pagbubukod habang nagpapatupad ang software. Dapat isama ng mga developer ang mga pahayag na nakakakuha upang asahan ang mga problema mula sa labas ng kanilang sariling source code ngunit ayusin ang mga problema na ipinakilala nila ang kanilang sarili.
