Error

Matakot sa mga error, ngunit huwag isulat ang mga ito sa Java! Malamang na alam mo na ang ilang bagay tungkol sa mga pagbubukod sa Java . Ngayon, hindi bababa sa isang mababaw na kaalaman ang makikinabang sa iyo. Susuriin namin ang klase ng Error at isang espesyal na uri ng pagbubukod na nakakatakot sa maraming tao kapag lumitaw ito sa kanilang mga stack traces.

Sa tuktok ng exception hierarchy ng Java ay ang Throwable class, na may dalawang inapo:

• Exception , na responsable para sa mga error sa iyong program.
• At ang ating bayani para sa ngayon — Error , na responsable para sa mga error sa JVM.
  Ito ay nagkakahalaga ng pagbanggit na ang mga ito ay malamang na hindi kahit na mga coding bug, ngunit sa halip mga problema na karaniwang hindi nakasalalay sa developer.

Ano ang gagawin sa isang Error

Kapag nakakuha ng "mga error", hindi ka makakagawa ng anumang mga aksyon sa catch block, maliban sa pag-log , dahil pinag-uusapan natin ang mga problema sa JVM mismo.

Maganda ang pag-log: kapag nakakuha ka ng runtime error, maaari mong tingnan ang mga log, tingnan ang sanhi nito, at malaman kung ano ang aayusin.

Dahil hindi mo alam kung anong uri ng error ang maaari mong makuha kapag isinulat mo ang iyong code, walang saysay na magsulat ng partikular na uri sa catch block. Ang paggamit ng Error class mismo ay hindi rin ang pinakamahusay na solusyon, dahil sa kasong ito, makakahuli ka lamang ng mga error.

Alinsunod dito, mas mainam na gamitin ang Throwable class, na maaaring mahuli ang parehong Error at Exception . Ano ang hitsura nito sa pagsasanay?

try {
    // Your code
} catch (OutOfMemoryError outOfMemoryError) {
    // Code to catch OutOfMemoryError
}

try {
    // Your code
} catch (Error error) {
    // Code to catch all Errors
}

try {
    // Your code
} catch (Throwable throwable) {
    // Code to catch all Throwables
}

Ang pangalawang opsyon para sa paghawak ng mga error ay itapon ang mga ito nang mas mataas pagkatapos magdeklara ng throws clause sa pamamaraan. Ginagamit ang diskarteng ito kapag ang iyong code ay maaaring maghagis ng error sa teorya at gusto mong paunang babalaan ang lahat na maaaring gumamit ng iyong code upang maayos nilang mahawakan ang error.

Mga karaniwang pagkakamali

Ang ilan sa mga pinakasikat na error ay ang OutOfMemoryError at StackOverflowError na mga klase.

Ang OutOfMemoryError ay madalas na lumalabas kapag ang program ay walang sapat na memorya upang lumikha ng mga bagay at ang tagakolekta ng basura ay hindi makakasabay. Ang resulta ay isang OutOfMemoryError .

Hindi ka pinapayagan ng Java na manual na magtanggal ng mga bagay upang maiwasan ang mga pagtagas ng memorya, ngunit maiiwasan mo ang magkalat upang hindi masyadong magtrabaho ang kolektor ng basura at hindi makalat ang tambak.

Halimbawa, ang code na tulad nito ay lilikha ng maraming basura sa memorya:

while (true) {
    new Object();
}

Ang pangalawang error na gusto kong sabihin sa iyo ay ang StackOverflowError , na itinapon kapag umapaw ang stack. Dahil ang stack ay pangunahing nag-iimbak ng mga lokal na variable, parameter, at method call, ang recursion (o isang recursive method na tawag) ay isang pangkaraniwang dahilan ng error na ito:

public void foo() {
    foo();
}

Upang maiwasan ang mga problema sa panahon ng pagpapatupad ng programa, ang mga modernong IDE ay madalas na nagbabala tungkol sa mga pamamaraan ng pagtawag nang paulit-ulit.

Hindi mo maaaring ayusin ang isang program na nagtatapon ng Mga Error , ngunit maaari kang magsulat ng code na hindi magtapon ng error at masira ang iyong programa. Panoorin kung ano ang iyong ginagawa gamit ang memorya, gumawa ng mga bagay nang maingat, at tumawag ng mga pamamaraan nang tama. Kung gagawin mo iyon, magkakaroon ka ng mas kaunting mga problema sa iyong code.

Pagkakaiba sa pagitan ng mga uri ng Error at Exception

Hindi ka makakatakas sa mga pagbubukod sa Java, ngunit hindi ka dapat matakot sa kanila. Kailangan mo lamang na maunawaan kung ano ang kinakatawan ng bawat uri at alam kung paano ito haharapin. Yan lamang para sa araw na ito! See you!