Java: pagbubukod at ang kanilang pangangasiwa

Anumang programa ay gumana stably lamang kung ang source code ay debugged, at walang mga kondisyon na maaaring maging sanhi hindi inaasahang sitwasyon. Ang proseso ng pansing mga posibleng pagkabigo ay isinasagawa sa programming stage. Upang gawin ito, ang nag-develop ay tumatagal sa account ang lahat ng mga inaasahan kinalabasan at mga pagtatangka upang limitahan ang epekto ng error sa gayon ay hindi ito maaaring makagambala sa pagpapatakbo ng mga programa, o humantong sa pagbagsak nito.

Kailan maaaring kailanganin mong exception paghawak

Sa Java, isang exception ay maaaring sanhi ng hindi tamang input ng user, walang pangangailangan para sa isang mapagkukunan o biglaang network pagtatanggal programa. Para sa kumportableng paggamit nilikha ng developer ng application, kailangan mong kontrolin ang paglitaw ng mga emerhensiyang sitwasyon. Ang mamimili ay hindi dapat magkaroon upang maghintay na umalis ang isang application, upang mawalan ng data bilang isang resulta ng isang unhandled exception, o bahagi lang ng isang mensahe ay lumilitaw na nagpapahiwatig na may nangyaring mali.

Paghawak Java mga pagbubukod

Ano ang dapat isaalang-alang? Ang Java wika ay may sariling built-in exception paghawak functionality. Of course, ang isang malaking porsyento ng mga error ay nahuli sa pamamagitan ng iba pang compilation yugto, ang sistema ay awtomatikong i-notify na ang paggamit nito ay hindi na maaari. Ngunit may ganitong uri ng pagbubukod na nangyayari sa runtime. developer ay dapat na magagawang upang asahan ang mga ito at upang mag-disenyo ang code sa gayon ay hindi ito maging sanhi ng isang error, at hawakan ito sa isang espesyal na paraan at ipinasa sa paglipas ng kontrol sa isa pang branch.

Sa Java, ito ay ipinapataw sa pamamagitan ng tagatala upang mahuli ang isang exception, kaya ang tipikal na problema ay kilala at magkaroon ng isang standard na pattern ehersisyo.

tipikal na pagbubukod

Ang pinakasimpleng halimbawa, kung saan maaari kang makakuha ng isang exception - ganitong paghahati. Sa kabila ng pagiging simple nito, sa mga tuntunin, bilang isang divider, ay maaaring zero, na kung saan ay magreresulta sa isang error. Well, kung ito ay posible upang mahulaan ang paglitaw ng nakaraan at pigilan. Ngunit ang pagpipiliang ito ay hindi palaging magagamit, kaya pansing pagbubukod ay dapat na nakaayos nang direkta sa kaganapan ng "hatiin sa pamamagitan ng zero".

Ang Java mekanismo upang harangin na error sa pagpoproseso ganito ang hitsura:

• heap exception object ay nilikha, pati na rin ang anumang iba pang mga;
• ang natural na kurso ng programa ay nagambala;
• exclusion mekanismo ay sinusubukan upang mahanap ang isang alternatibong paraan upang ipagpatuloy ang code;
• Maghanap ng isang ligtas na pagpapatupad ng programa sa processor, trabaho o naibalik, o ay magaganap pagsasakatuparan ng exception sa isang espesyal na paraan.

Ang pinakasimpleng halimbawa ng paglikha ng isang error ay maaaring magmukhang ito:

kung (a == null)

magtapon ng mga bagong NullPointerException ();

Dito, ang mga variable ng isang ay naka-check sa initialization, ie, ay hindi kung ang reference sa isang null object. Kung situasyon na ito ay arisen at kailangan ng espesyal na paghawak, ang isang exception ay hagis sa pamamagitan ng isang throw bagong NullPointerException ().

Ang ilang mga detalye tungkol sa mga keyword

Kapag pagharap sa mga pagbubukod ay madalas na kinakailangan upang gamitin ang keyword Java na mag-refer sa isang partikular na pagkilos. Ito wika ng kanilang limang programming:

• Subukan. Ang keyword na ito ay nai-nakilala, at ito ay nangangahulugan ng isang transition sa isang seksyon ng code na maaari ihagis ng isang exception. I-block ang limitadong braces {}.
• Catch. Ito intercepts ang nais na i-type ang kataliwasan at hawakan ito nang naaangkop.
• Sa wakas. Ang keyword na ito ay opsyonal at ay ginagamit upang maisagawa ang isang tiyak na piraso ng code, na kung saan ay kinakailangan pa rin, kahit na walang mga exception ay hindi mahuli. Idinagdag direkta pagkatapos try block.
• Itapon - hinahayaan kang lumikha Java mga pagbubukod mula sa kahit saan.
• Throws - isang keyword na iyon ay nakalagay sa signature paraan. Ito ay nangangahulugan na ang mga sumusunod na code ay maaaring ihagis ng isang exception sa ganitong uri Java. Markahan na ito ay nagsisilbi bilang isang signal sa mga developer na kailangan upang maging makitid ang isip sa isip - ang pamamaraan ay hindi maaaring gumana tulad ng inaasahan sa kanya.

Pansing may isang try

Bitawan upang Java mga pagbubukod, natural Ipinapalagay na ito ang panghahawakan sa isang espesyal na paraan. Ang pinaka-maginhawang paraan upang gawin ito, kung ang code na seksyon ay nabakuran off sa isang block. Na maaaring maglaman ng isang exception. Kapag nagpatakbo ka ng code na ito, ang virtual machine ay makakahanap ng isang hindi inaasahang sitwasyon, maunawaan na may isang kritikal na block at transfer control sa estasyon sa processing.

Ang Java code ay nakabalot sa isang espesyal na block try, sa loob na maaaring maging isang exception. Kaya, siya ay inilagay ang ilang mga hindi inaasahan sitwasyon na ay nahuli sa parehong lugar, hindi raspolzayas code.

Ang pinaka-tipikal na code sa processing unit ay ang mga sumusunod:

try {

// Narito ang ilang mga code na maaaring makabuo ng isang exception

} Catch (Tip_isklyucheniya_1 identifikator_1) {

// Narito mayroong exception paghawak, ayon sa kanyang uri at kondisyon;

} Catch (Tip_isklyucheniya_2 identifikator_2) {

// Narito mayroong exception paghawak, ayon sa kanyang uri at kondisyon;

}

Keyword catch ang mga ulat na code, at i-scan ito para sa isang exception, upang tratuhin tulad ng inilarawan sa ibaba, sa kondisyon na ito ay sumusunod sa uri nito. identifier ay maaaring gamitin sa pagproseso ng code block bilang argumento.

sa wakas

Bilang ito ay naging malinaw na mula sa nakaraang kabanata, catch bloke mahuli eksepsiyon at iproseso ang mga ito. Ngunit napakadalas ang sitwasyon arises kung saan dapat tumakbo ng ilang mga code, hindi alintana kung sila ay nahuli pagkakamali. Dahil dito ay may mga keyword sa wakas. Ito ay ginagamit upang dagdagan ang mga halaga ng iba't-ibang mga counter, pagsasara ng mga file o mga koneksyon sa network.

isang lagay ng lupa na ito ay nagtatanghal ng ilang mga catch blocks imbento pamamaraan mahuli eksepsiyon. Halimbawa, ang code na nakapaloob sa subukan mo ito ay bumubuo ng isang hindi inaasahang sitwasyon tulad ng Cold. Pagkatapos, ang console ay ipapakita expression «Nahuli malamig!» At «Iyan ba ang isang bagay upang magsaya tungkol sa?». Iyon ay, ang wakas block ay pinaandar sa anumang kaso.

Sa katunayan, isang paraan upang maiwasan ang nagpapalitaw sa wakas doon. Ito ay konektado sa pagkumpleto ng mga virtual machine. Hanapin kung paano ipatupad ito, ito ay posible sa Internet open space.

throw keyword

Throw ay bumubuo ng isang exception. Nito syntax ay ang mga sumusunod:

magtapon ng mga bagong NewException ();

May ay lumikha ng isang bagong exception sa uri NewException (). Bilang isang uri ay maaaring magamit ay kasama sa standard na mga klase Java library at dati nang tinukoy ng nag-develop ng sarili nitong produksyon.

Disenyo na ito ay bahagi ng pagganap ng anumang mga pamamaraan, na kung saan ang tawag ay dapat pagkatapos ay magaganap sa loob ng try block, upang magagawang upang harangin ito.

throws keyword

Paano kung nasa proseso ng pag-unlad ng isang sitwasyon kung saan ang pamamaraan ay maaaring ihagis ng isang exception, ngunit hindi magagawang upang mahawakan nang maayos. Sa pagtatapos na ito, sa signature paraan ng tumutukoy ang salitang throws at uri ng mga posibleng pagbubukod.

Ang label na ito ay isang uri ng indicator para sa mga developer client na ang paraan na ito ay hindi magagawang upang pangasiwaan ang kanilang mga parehong exception. Sa karagdagan, kung ang uri ng error ay naka-check, pagkatapos ay ang compiler pipilitin tahasang magtanong para dito.

Subukan na mapagkukunan

Ang Java bersyon 7-develop na isinama ang isang malaking pagbabago, bilang isang paggamot try block na may mga resources.

Maraming mga bagay ay nilikha sa Java, pagkatapos gamitin ay dapat na shut down upang makatipid sa mga mapagkukunan. Dati ito ay nagkaroon na kumuha ito sa account at itigil ang mga pagkakataong ito mano-mano. Ngayon, gayunpaman, ang mga ito ay lumitaw AutoClosable interface. Ito ay tumutulong upang awtomatikong isara ginagamit na mga bagay na inilagay sa isang try block. Sa pamamagitan ng ang paraan na ito ito ay maging mas maginhawa upang isulat ang code sa kanyang pagiging madaling mabasa ay makabuluhang tumaas.

Sariling klase Java mga pagbubukod

Ang mga tagalikha ng mga inilarawan programming language kinuha sa account maraming aspeto ng mga uri ng disenyo ng emergency. Gayunpaman, ang lahat ng mga pagpipilian upang maiwasan ang kinalabasan ng mga kaganapan ay hindi gagana, kaya sa Java ipinatupad ng kakayahan upang tukuyin ang kanilang sariling mga pagbubukod, ito ay angkop sa mga pangangailangan ng partikular na code.

Ang pinakasimpleng paraan upang lumikha ng - upang magmana mula sa ang pinaka-angkop sa bagay na konteksto.

May nangyari na magmana mula sa Exception, ang klase na ginagamit upang tukuyin ang iyong sariling mga pagbubukod. Sa MyException ay may dalawang constructor - isang default, ang pangalawang - gamit ang argument msg type String.

Pagkatapos, sa mga pampublikong silid-aralan FullConstructors ipinatupad pamamaraan sa f, na naglalaman ng signature throws MyException. Ang keyword na ito ay nangangahulugan na ang f ay maaaring magtapon ng tulad ng Java MyException exception. Dagdag dito, sa katawan paraan na ginawa text output impormasyon sa console mismo at ang mga aktwal na henerasyon MyException, sa pamamagitan ng throw.

Ang ikalawang paraan ay bahagyang naiiba mula sa unang isa na kapag lumikha ka ng isang exception, ito ay pumasa sa isang string parameter, na kung saan ay sasalamin sa ang console sa pansing. Sa pangunahing ito ay malinaw na ang f () at g () ay inilalagay sa isang try checking at keyword catch-configure upang makuha MyException. Ang resulta ng pagpoproseso ay upang ipakita ang isang mensahe ng error sa console:

Kaya ito ay dumating upang magdagdag Java mga pagbubukod, sa pamamagitan ng kanyang sariling kamay.

Arkitektura pagbubukod

Tulad ng lahat ng mga bagay sa Java, mga pagbubukod ay din minana at magkaroon ng isang hierarchical istraktura. Ang root element ng lahat ng mga error itinapon sa ito programming wika ay klase java.lang.Throwable. Minana mula sa kanya ang dalawang uri - Error at Exception.

Error - naghuhudyat ng kritikal na error at walang check Java mga pagbubukod. Pagharang at pagproseso ng naturang data sa karamihan ng mga kaso ay nangyayari sa entablado disenyo at hindi nangangailangan ng pagpapasok sa panghuling application code.

Ang pinaka-karaniwang ginagamit na klase para sa paglikha at pag-aaral ang mga pagbubukod ay Exception. Aling, sa pagliko, ay nahahati sa ilang mga sanga, kabilang ang RuntimeException. Sa pamamagitan ng RuntimeException ay runtime pagbubukod, iyon ay, na nagaganap sa panahon ng programa. Ang lahat ng mga klase nagmula mula sa mga ito ay hindi nabe-verify.

Kadalasan may mga pagbubukod

Sa Java mga pagbubukod, ang listahan ng mga na kung saan ay iniharap sa ibaba, ay ginagamit pinaka-madalas, kaya dapat mong ilarawan ang bawat isa sa kanila nang detalyado:

• ArithmeticException. Kabilang dito ang mga error na kaugnay sa arithmetic operation. Ang pinaka-napakatingkad halimbawa - ang dibisyon ng zero.
• ArrayIndexOutOfBoundsException - isang apela sa elemento number array na lumampas sa kabuuang haba nito.
• ArrayStoreException - pagtatangka upang magtalaga ng hindi tugmang i-type ang elemento ng array.
• ClassCastException - isang pagtatangka upang dalhin ang mali sa isang uri sa isa pa.
• IllegalArgumentException - gamit ang maling argumento sa tawag na paraan.
• NegativeArraySizeException - isang exception kapag lumikha ka ng isang array ng mga negatibong laki.
• NullPointerException - maling paggamit ng mga sanggunian sa null.
• NumberFormatException - nangyayari kapag ang isang maling string conversion sa integer.
• UnsupportedOperationException - operasyon ay hindi suportado.

Ang mga halimbawang ito ay kumakatawan sa mga uri ng mga walang check Java mga pagbubukod. Ngunit kaya hitsura nasuri:

• ClassNotFoundException - Class hindi nahanap.
• IllegalAcccessException - rendahan ang access sa mga klase.
• InterruptedException - pagkagambala sa ang daloy.
• NoSuchFieldException - walang kinakailangang patlang.

Ang interpretasyon ng mga pagbubukod

Pagsasalita ng mga madalas na nakatagpo ng mga pagbubukod ay dapat na nabanggit na ang kanilang interpretasyon sa disenyo, ay maaaring pinaghihinalaang hindi tama. Susunod ay isang maikling listahan nagpapaliwanag nang mas detalyado, kung saan maaaring may isang hindi inaasahang sitwasyon.

NullPointerException. Ang napaka-unang kaso kapag may isang exception, ay upang mag-apela sa isang reference sa isang bagay na katumbas sa null. Ito rin ay umaabot sa zero pamamaraan Halimbawa klase. NullPointerException ay maaaring thrown sa kaso ng pagkuha ng pantay na haba null array. Upang maiwasan ang ganitong sitwasyon ay panaka-nakang suriin ang site sa null.

ArrayIndexOutOfBoundsException. Anumang programa ay hindi maaaring umiiral nang walang ang paggamit ng array. Alinsunod dito, ang mga madalas na humingi ng tulong sa maaari itong bumuo at error. Exception ay nangyayari kapag ang isang developer sumusubok na ma-access ang isang array na sangkap na ay wala sa listahan index. Halimbawa, ang hiniling na halaga ay sa itaas o ibaba zero haba. Kadalasan ay isang resulta ng ang katunayan na sa array ay nagsisimula sa isang marka ng zero.

napag-alaman

Paghawak Java mga pagbubukod - isang makapangyarihang kasangkapan na kapaligiran, na lubos na facilitates ang gawain ng mga programmer at nagbibigay-daan sa kanya upang lumikha ng isang malinis at walang wala ng error code. Sa kung paano makinis at matatag na gumagana application ay depende sa kalagayan at reputasyon ng nag-develop.

Of course, sa isang higit pa o mas simpleng programa upang trace abnormal sitwasyon lubhang mas madaling. Ngunit sa mga malalaking automated complexes para sa isang ilang daang libong mga linya ng ito ay posible lamang bilang isang resulta ng pang-matagalang pagsubok at debugging.

Para sa Java error exception mula sa kung saan lumabas dahil sa ilang mga aplikasyon, ang ilang mga kumpanya ay nag-aalok ng isang gantimpala kapag nakita nila Panatiko. Lalo na pinapahalagahan ng mga na maging sanhi ng paglabag ng seguridad ng patakaran software.