1. Mga pagbubukod
>
Sa wakas, naisip ng mga programmer na i-standardize at i-automate ang paghawak ng error. Nangyari ito noong naimbento ang mga eksepsiyon . Ngayon ang mekanismo ng pagbubukod ay humahawak ng 80% ng mga pambihirang sitwasyon.
Kung ang ilang iskolar ay may mga eksepsiyon, malamang na ito ang paksa ng kanyang disertasyong pang-doktor. Kung naisip ito ng isang programmer, maaaring nakatanggap siya ng magiliw na tapik sa likod mula sa isang katrabaho: "Mukhang okay, bro."
Kapag may naganap na error sa isang Java program, tulad ng paghahati sa pamamagitan ng 0
, ang ilang magagandang bagay ay nangyayari:
Unang hakbang
Ang isang espesyal na object ng exception ay nilikha, na naglalaman ng impormasyon tungkol sa error na naganap.
Ang lahat sa Java ay isang bagay, at ang mga eksepsiyon ay walang mga eksepsiyon 🙂 Ang mga bagay sa pagbubukod ay may sariling mga klase, at ang tanging bagay na nagpapaiba sa kanila mula sa mga ordinaryong klase ay ang pagmamana nila sa klase Throwable
.
Ikalawang hakbang
Ang exception object ay "itinapon". Marahil ang mga salita dito ay maaaring maging mas mahusay. Ang "paghagis ng exception" ay mas katulad ng pagti-trigger ng alarma sa sunog o pagpapatunog ng alertong "DEFCON 1."
Kapag ang isang pagbubukod ay itinapon sa Java machine, ang normal na operasyon ng programa ay hihinto at magsisimula ang "mga emergency na protocol".
Ikatlong hakbang
Ang paraan kung saan ang pagbubukod ay itinapon ay lumabas kaagad. Ang pagbubukod ay ipinapasa sa paraan ng pagtawag, na agad ding lalabas. At iba pa pababa sa kadena hanggang sa main
lumabas ang pamamaraan. Kapag main
natapos ang pamamaraan, ganoon din ang programa.
Halimbawa:
Code | Output ng console |
---|---|
|
|
Ang isang pagbubukod ay nangyayari sa linya 20: paghahati ng 0. Ang Java machine ay agad na lumilikha ng isang pagbubukod - isang ArithmeticException
bagay at "itinapon" ito sa pamamaraan.
Ang divide()
pamamaraan ay nagtatapos kaagad, kaya hindi namin nakikita ang string: Walang kakila-kilabot na nangyari: 0. Ang programa ay bumalik sa endTheWorld()
pamamaraan, at ang sitwasyon ay nauulit mismo: mayroong isang hindi nahawakang pagbubukod sa system, na nangangahulugan na ang endTheWorld()
pamamaraan ay nagwawakas din nang hindi normal. Pagkatapos ay magtatapos ang main
pamamaraan, at huminto ang programa.
Ano ang layunin ng mga pagbubukod na ito? Kaya, maaari kang sumulat ng iyong sariling code upang mahuli ang mga partikular na uri ng mga pagbubukod at isulat ang iyong sariling lohika upang mahawakan ang mga pambihirang sitwasyon.
2. Mga pagbubukod sa paghuli:try-catch
Ang Java ay may exception catching mechanism na hinahayaan kang ihinto ang abnormal na pagwawakas ng mga pamamaraan. Mukhang ganito:
try
{
// Code where an exception might occur
}
catch(ExceptionType name)
{
// Exception handling code
}
Ang construct na ito ay tinatawag na try-catch
block.
Ang code kung saan maaaring mangyari ang mga pagbubukod ay nakabalot sa mga kulot na brace, na pinangungunahan ng salita try
.
Pagkatapos ng mga kulot na braces, mayroon kaming catch
keyword at, sa loob ng mga panaklong, ang deklarasyon ng isang exception variable . Sinusundan ito ng mga kulot na brace na bumabalot sa code na ipapatupad kung may pagbubukod sa tinukoy na uri .
Kung walang mga pagbubukod na itinapon sa panahon ng pagpapatupad ng " pangunahing code ", kung gayon ang code sa loob ng catch block ay hindi isasagawa. Kung may mangyayaring exception, magiging (kung ang uri ng itinapon na exception ay kapareho ng uri ng variable sa mga panaklong).
Halimbawa:
Code | Output ng console |
---|---|
|
|
3. Maramihang catch
mga bloke
Sa teorya, ang lahat ng uri ng mga pagbubukod ay maaaring itapon sa isang bloke ng code. Ang ilan ay gugustuhin mong pangasiwaan ang isang paraan, ang iba sa ibang paraan, at ang iba pa ay magpapasya kang huwag nang hawakan.
Nagpasya ang mga developer ng Java na tulungan ka at hayaan kang magsulat ng hindi isa ngunit maraming catch
mga bloke pagkatapos ng try
bloke.
try
{
// Code where an exception might occur
}
catch (ExceptionType1 name1)
{
// Code for handling ExceptionType1
}
catch (ExceptionType2 name2)
{
// Code for handling ExceptionType2
}
catch (ExceptionType3 name3)
{
// Code for handling ExceptionType3
}
Halimbawa:
Code | Output ng console |
---|---|
|
|
4. Pagkakasunud-sunod ng catch
mga bloke
Ang mga pagbubukod na nangyayari sa isang try
bloke ay maaari lamang mahuli ng isang catch
bloke. Hindi ka maaaring magkaroon ng exception sa paghawak ng sitwasyon kung saan ang code mula sa maraming catch
mga bloke ay maipapatupad.
Ngunit ang pagkakasunud-sunod ng mga bloke ay mahalaga.
Maaari kang magkaroon ng isang sitwasyon kung saan ang isang pagbubukod ay maaaring makuha ng maraming mga bloke. Kung iyon ang kaso, ang exception ay mahuhuli ng alinmang catch block ang mauna (pinaka malapit sa try
block).
Paano ka magkakaroon ng sitwasyon kung saan maraming catch block ang makakahuli ng parehong exception?
Ang lahat ng mga pagbubukod ay nabibilang sa isang hierarchy ng mana — tingnan ang diagram.
ArithmeticException
Maaaring italaga ang isang bagay sa isang variable na ang uri ay ArithmeticException
o alinman sa mga ninuno nitong klase: RuntimeException
, Exception
at Throwable
— tingnan ang diagram.
Pag-uusapan pa natin ang tungkol sa inheritance at ancestor class sa Level 21.
Ang code na ito ay mag-compile nang maayos:
Mga benepisyo ng mana: |
---|
|
Para mahuli mo ang ArithmeticException
alinman sa 4 catch
na bloke sa itaas.
Halimbawa 1:
Code | Output ng console |
---|---|
|
|
Sa halimbawang ito, ang ArithmeticException
maaaring mahuli ng parehong catch (Exception e)
at catch (ArithmeticException e)
mga bloke. Mahuhuli ito ng block na pinakamalapit sa try
block — ang unang catch
block.
Upang maiwasan ang mga sorpresa, pinakamahusay na maglagay catch
ng mga bloke na maaaring makahuli sa halos lahat ng pagbubukod malapit sa dulo ng listahan ng catch
mga bloke.
Ang Throwable
uri ay karaniwang may kakayahang makuha ang bawat posibleng pagbubukod sa Java . Kung ilalagay mo ito sa unang catch
bloke, hindi mako-compile ang code, dahil alam ng compiler na may mga hindi maabot na bloke ng code.