Sinuri at Hindi Naka-check Exception

Ang paghawak sa pagbubukod sa Java ay isa sa mga makapangyarihang mekanismo upang mahawakan ang mga tiyak na mga error na lumabas sa isang pagkakasunud-sunod ng code sa runtime. Ang isang eksepsiyon ay walang anuman kundi isang error sa runtime na nakakagambala sa normal na daloy ng aplikasyon.

Ito ay karaniwang nangyayari sa isang piraso ng code at kapag ginagawa nito, isang bagay na kumakatawan sa pagbubukod na iyon ay nilikha at itinapon sa paraan na naging sanhi nito. Bilang isang resulta, ang programa o application ay nawalan ng pinsala na nagdudulot na wakasan ang application na hindi normal, na hindi inirerekomenda. Ito ang dahilan kung bakit ang mga pagbubukod na ito ay hawakan at ito ay kung saan ang mekanismo sa paghawak ng eksepsiyon ay dumating sa larawan.

Mayroong dalawang uri ng mga eksepsiyon na umiiral sa Java - Sinuri at Walang Check Exception. Sa artikulong ito, tatalakayin namin nang detalyado kung ano ang naka-check at walang check exception at kung kailan gamitin ito, at sa wakas, makikita natin ang pagkakaiba sa pagitan ng dalawa.

Ano ang Checked Exception sa Java?

Ito ang mga eksepsiyon na sinusuri at hinahawakan sa oras ng pag-compile. Tinutukoy ng Java ang ilang klase ng pagbubukod sa loob ng karaniwang pakete java.lang, at ang mga pinaka-karaniwang eksepsiyon ay mga subclasses ng karaniwang uri RuntimeException.

Ang mga eksepsiyong nagaganap sa mga lugar sa labas ng agarang kontrol ng programa ay kilala bilang mga eksepsiyon na naka-check. Kung ang isang paraan throws isang naka-check na pagbubukod sa oras ng pag-compile na hindi maaaring panghawakan ito mismo, pagkatapos ay dapat itong hawakan ang pagbubukod sa a catch {} harangan o ideklara ang pagbubukod gamit ang throws keyword, kung hindi, ito ay magbibigay ng error sa compilation. Sinusuri ng tagatala ang uri ng pagbubukod ng bagay para sa bawat isa itapon pahayag at kung ito ay nagpapakita ng tsek, ang tagatala ay nagsusuri sa source code upang matiyak na ang pagbubukod ay hawakan sa paraan kung saan ito ay itinapon o ipinahayag upang maaari itong mapangasiwaan ng karagdagang.

Lahat ng mga pagbubukod na inilarawan sa pamamagitan ng Exception na kung saan ay ang direktang subclasses maliban para sa RuntimeException ay tinatawag na mga eksepsiyon na naka-check. Ngayon kapag gumamit ng naka-check na eksepsiyon? Maaari mong piliing gumamit ng isang naka-check na eksepsiyon kung alam mo kung ano ang dapat gawin kapag ang isang Exception nangyayari o kapag ang mga pagkakataon ng pagkabigo ay higit pa. Ang ilang mga halimbawa ng mga eksepsiyon na naka-check sa library ng Java ay ang IOException, DataAccessException, IllegalAccessException, InterruptedException, ClassNotFoundException, InvocationTargetException, atbp.

Ano ang Unchecked Exception sa Java?

Ito ang mga eksepsiyon na hindi naka-check sa oras ng pag-compile. Ang Unchecked Exception ay kumakatawan sa isang kalagayan na sa pangkalahatan ay nagpapakita ng mga pagkakamali sa lohika ng isang programa at hindi maaaring mabawi mula sa runtime.

Sa mga simpleng termino, ang hindi nakikitang pagbubukod ay isang eksepsiyon na hindi nahuli sa isang subukan-catch harangan. Hindi nila kailangang mahuli nang tahasan. Sa katunayan, kapag ang isang hindi nakikitang eksepsiyon ay nangyayari, ang Java ay humahawak ng eksepsyon awtomatikong. Ang mga hindi naka-check na eksepsiyon ay kadalasang nangyari dahil sa mga error sa programming tulad ng kapag nag-access ng elemento sa labas ng isang array bonding o pag-access ng paraan ng isang null object. Sa Java, ang lahat ng mga eksepsiyon sa ilalim ng throwable ay naka-check na mga eksepsiyon, samantalang ang mga eksepsyon na direktang subclasses ng Error at RuntimeException ay walang mga eksepsiyon.

Ang pinakamagandang bahagi ng isang hindi naka-check na pagbubukod ay hindi ito binabawasan ang pagiging madaling mabasa ng code habang pinapanatili ang malinis na code ng kliyente. Ang ilang mga halimbawa ng mga hindi naka-check na eksepsiyon ay ang ArithmeticException, ClassCastException, NullPointerException, ArrayIndexOutOfBound, IllegalArgumentException, IllegalStateException, ArrayStoreException, SecurityException, atbp.

Pagkakaiba sa pagitan ng Checked at Unchecked Exception

Kahulugan ng Checked at Unchecked Exception

Ang Checked at Unchecked Exception ay ang dalawang uri ng mga eksepsyon na umiiral sa Java upang matiyak ang normal na daloy ng aplikasyon. Parehong maglingkod sa parehong layunin na upang pangasiwaan ang mga eksepsiyon sa Java at bagaman walang pagkakaiba sa pag-andar, walang iisang panuntunan upang matukoy kung kailan gagamitin ang naka-check at kung kailan gagamitin ang hindi naka-check na eksepsiyon. Ang Checked Exception ay isang eksepsiyon na nasuri sa oras ng pag-compile, samantalang ang Unchecked Exception ay ang hindi siniyasat sa oras ng pag-compile.

Mga Pangunahing Kaalaman ng Sinusuri at Hindi Naka-check Exception

Ang isang naka-check na eksepsiyon ay tumutukoy sa mga di-wastong mga sitwasyon na nangyari sa labas ng agarang kontrol ng programa samantalang ang walang check na pagbubukod ay tumutukoy sa mga error sa programa o mga bug sa logic ng programa na hindi maaaring makuha mula sa runtime.

Paghawak ng Eksepsiyon

Kung ang isang paraan ay nagtatapon ng isang naka-check na eksepsiyon, susuriin ng tagatala kung ang pamamaraan ay paghawak sa eksepsiyon gamit ang block ng try-catch o tukuyin ang pagbubukod gamit ang throws keyword. Kung ang pamamaraan ay hindi nagbibigay ng handling code, ito ay magpapakita ng error sa compilation. Sa kabaligtaran, ang programa ay binubuo lamang ng mahusay dahil ang tagatala ay hindi nag-check para sa mga Checkout na Walang Check sa oras ng pag-compile.

Maging sanhi ng Sinusuri at Hindi Naka-check Exception

Ang mga eksepsyon na hindi nakuha mula sa RunTimeException ay madalas na hawakan samantalang ang mga pagbubukod ay nagaganap sa runtime ay bihirang hawakan. Ang isang Checked Exception ay nangyayari kapag ang mga pagkakataon ng kabiguan ay masyadong mataas. Ang hindi naka-check na Exception, sa kabilang banda, ay nangyayari karamihan dahil sa mga pagkakamali ng programming. Ang lahat ng mga eksepsiyon sa ilalim ng mga klase ng RuntimeException at Error ay walang naka-check na mga eksepsiyon, samantalang ang lahat ng bagay sa ilalim ng throwable ay naka-check na mga eksepsiyon.

Mga Halimbawa ng Sinuri at Hindi Naka-check Exception

Ang ilang mga halimbawa ng mga eksepsiyon na naka-check ay IOException, DataAccessException, IllegalAccessException, InterruptedException, ClassNotFoundException, at higit pa. Ang mga halimbawa ng mga hindi naka-check na eksepsiyon ay ang NullPointerException, ArithmeticException, ArrayIndexOutOfBound, IllegalArgumentException, IllegalStateException, ArrayStoreException, SecurityException, atbp.

Sinusuri kumpara sa Walang Check Exception: Tsart ng Paghahambing

Buod ng Sinusuri at Hindi Naka-check Exception

Ang Checked at Unchecked Exception ay ang dalawang uri ng mga pagbubukod na umiiral sa Java. Habang ang pag-andar ay pareho para sa parehong mga pagbubukod, mayroon silang kanilang makatarungang bahagi ng mga pagkakaiba. Ang pangunahing pagkakaiba sa pagitan ng naka-check at hindi naka-check na mga eksepsiyon ay na ang dating ay nasuri ng tagatala samantalang ang huli ay nakaligtaan sa paunawa ng tagatala. Ang mga eksepsiyon na sinusuri at hinahawakan sa panahon ng pag-compile ay naka-tsek na mga eksepsiyon, samantalang ang mga eksepsiyon na hindi siniyasat at hinahawakan sa oras ng pag-compile ay walang naka-check na eksepsiyon. Ipinaliliwanag ng artikulong ito kung ano ang nasuri at kung ano ang hindi napansin ng pagbubukod, kapag ginagamit ito, at ipinaliliwanag ang pagkakaiba ng dalawa.