Kaip teisingai elgtis su „Java“ išimtimis

IllegalArgumentException
Norėdami sugauti šią išimtį, turite eiti kur
someMethod()
yra vadinamas ir naudojamas bandymo gaudyti blokas :
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Viskas viduje bandyti blokas bus vykdomas eilės tvarka, kol bus išmesta išimtis. Kai tik išmetama išimtis, visi vėlesni teiginiai praleidžiami ir taikymo logika iškart pereina prie pagauti blokuoti.
 
Mūsų pavyzdyje mes įvedame bandymo bloką ir nedelsdami skambiname
someMethod()
. Kadangi 200 nėra tarp 0 ir 100, an
IllegalArgumentException
yra išmestas. Tai nedelsiant baigia vykdyti
someMethod()
, praleidžia likusią logiką bandymų bloke (
someOtherMethod()
niekada nešaukiamas) ir atnaujinamas vykdymas gaudymo bloke.
 
Kas būtų, jei paskambintume
someMethod(50)
vietoj to? The
IllegalArgumentException
niekada nebūtų išmestas.
someMethod()
vykdytų kaip įprasta. Bandymo blokas būtų vykdomas kaip įprasta, skambinant
someOtherMethod()
kai someMethod () bus baigtas. Kada
someOtherMethod()
baigiasi, sugavimo blokas būtų praleistas ir
callingMethod()
tęstųsi.
 
Atminkite, kad viename bandymo bloke galite turėti kelis sugavimo blokus:
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 } catch (NullPointerException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Taip pat atkreipkite dėmesį, kad neprivaloma pagaliau blokas taip pat egzistuoja:
public void method() {  
 try {  
 // ...  
 } catch (Exception e) {  
 // ...  
 } finally {  
 // ...  
 }  
}
Galutiniame bloke esantis kodas yra visada įvykdyta nesvarbu. Jei bandymo bloke turite grąžinimo pareiškimą, galutinis blokas vykdomas prieš grįžtant iš metodo. Jei į sugavimo bloką įmesite kitą išimtį, galutinis blokas vykdomas prieš išmetant išimtį.
 
Galutinį bloką turėtumėte naudoti, kai turite objektų, kuriuos reikia išvalyti prieš pasibaigiant metodui. Pvz., Jei atidarėte failą bandymų bloke ir vėliau padarėte išimtį, galutinis blokas leidžia uždaryti failą prieš paliekant metodą.
 
Atminkite, kad galutinai galite užblokuoti be fiksavimo bloko:
public void method() {  
 try {  
 // ...  
 } finally {  
 // ...  
 }  
}
Tai leidžia atlikti visus būtinus valymus, o metamos išimtys gali išplatinti metodo iškvietimo krūvą (t. Y. Nenorite tvarkyti išimties čia, bet vis tiek pirmiausia turite išvalyti).
 
„Java“ pažymėtos ir nepažymėtos išimtys
Skirtingai nuo daugelio kalbų, „Java“ skiria skirtumus patikrino išimtis ir nekontroliuojamos išimtys (pvz., C# yra tik nepažymėtų išimčių). Patikrinta išimtis privalo būti sugautas metodu, kuriame išmetama išimtis, kitaip kodas nebus sukompiliuotas.
 
Norėdami sukurti pažymėtą išimtį, pratęskite nuo
Exception
. Norėdami sukurti nepažymėtą išimtį, pratęskite nuo
RuntimeException
.
 
Bet kuris metodas, kuris išmeta pažymėtą išimtį, turi tai pažymėti metodo parašu, naudojant meta raktinis žodis. Kadangi „Java“ yra integruota
IOException
yra pažymėta išimtis, šis kodas nebus sukompiliuotas:
public void wontCompile() {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Pirmiausia turite pareikšti, kad ji daro pažymėtą išimtį:
public void willCompile() throws IOException {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Atkreipkite dėmesį, kad metodas gali būti paskelbtas išimties metimu, bet iš tikrųjų niekada nemeta išimties. Nepaisant to, išimtį vis tiek reikės sugauti, kitaip kodas nebus sukompiliuotas.
 
Kada turėtumėte naudoti pažymėtas ar nepažymėtas išimtis?
 
Oficialioje „Java“ dokumentacijoje yra puslapis apie šį klausimą . Skirtumas apibendrinamas glausta nykščio taisykle: „Jei pagrįstai galima tikėtis, kad klientas atsigaus nuo išimties, padarykite tai pažymėta išimtimi. Jei klientas negali nieko padaryti, kad atsigautų nuo išimties, padarykite tai nepažymėta išimtimi. “
 
Tačiau ši gairė gali būti pasenusi. Viena vertus, patikrintos išimtys suteikia tvirtesnį kodą. Kita vertus, jokia kita kalba nepatikrino išimčių taip pat, kaip „Java“, o tai rodo du dalykus: viena, ši funkcija nėra pakankamai naudinga, kad kitos kalbos ją pavogtų, ir, antra, jūs galite visiškai gyventi be jų. Be to, patikrintos išimtys nelabai žaidžia su „lambda“ išraiškomis, įdiegtomis „Java 8“.
 
„Java“ išimčių naudojimo gairės
 
Išimtys yra naudingos, tačiau lengvai piktnaudžiaujama ir piktnaudžiaujama. Pateikiame keletą patarimų ir geriausios praktikos, padėsiančių išvengti jų netvarkos.
 
 
  Pirmenybę teikite konkrečioms išimtims, o ne bendroms. Naudokite | _+_ | per | _+_ | jei įmanoma, naudokite | _+_ | per | _+_ | kai įmanoma.
 
  Niekada nesugauk | _+_ | ! | _+_ | klasė iš tikrųjų tęsiasi | _+_ | , o gaudymo blokas iš tikrųjų veikia su | _+_ | ar bet kuri klasė, kuri apima „Throwable“. Tačiau | _+_ | klasė taip pat tęsiasi | _+_ | , ir jūs niekada nenorite pagauti | _+_ | nes | _+_ | rodo rimtas nepataisomas problemas.
 
  Niekada nesugauk | _+_ | ! | _+_ | tęsiasi | _+_ | , taigi bet koks blokas, kuris sugauna | _+_ | taip pat pagaus | _+_ | , ir tai yra labai svarbi išimtis, su kuria nenorite kištis (ypač naudojant daugiasluoksnes programas), nebent žinote, ką darote. Jei nežinote, kurią išimtį gaudyti, apsvarstykite galimybę nieko neužgauti.
 
  Norėdami palengvinti derinimą, naudokite aprašomuosius pranešimus. Įvesdami išimtį, galite pateikti | _+_ | pranešimą kaip argumentą. Šį pranešimą galima pasiekti sugavimo bloke naudojant | _+_ | metodas, tačiau jei išimtis niekada nepastebima, pranešimas taip pat bus rodomas kaip kamino pėdsako dalis.
 
  Stenkitės nepagauti ir nekreipti dėmesio į išimtis. Norėdami išvengti nepatogumų, susijusių su patikrintomis išimtimis, daugelis naujokų ir tingių programuotojų sukurs sugavimo bloką, bet paliks jį tuščią. Blogai! Visada tvarkykite tai grakščiai, bet jei negalite, bent jau atsispausdinkite kamino pėdsaką, kad žinotumėte, jog išimtis buvo išmesta. Tai galite padaryti naudodami | _+_ | metodas.
 
  Saugokitės pernelyg didelių išimčių. Kai turi plaktuką, viskas atrodo kaip vinis. Kai pirmą kartą sužinosite apie išimtis, galite jaustis įpareigotas viską paversti išimtimi ... tiek, kad dauguma jūsų programos valdymo srauto priklauso nuo išimčių tvarkymo. Atminkite, kad išimtys skirtos „išskirtiniams“ įvykiams!
 
 
Dabar turėtumėte būti pakankamai patogūs su išimtimis, kad suprastumėte, kas jie yra, kodėl jie naudojami ir kaip juos įtraukti į savo kodą. Jei iki galo nesuprantate sąvokos, tai gerai! Prireikė šiek tiek laiko, kol „spragtelėjau“ galvoje, todėl nesijausk, kad reikia skubėti. Neskubėk.
 
  Turite klausimų? Ar žinote kitų patarimų, susijusių su išimtimis? Pasidalykite jais toliau pateiktose pastabose!  
  Dalintis    Dalintis      „Tweet“      Paštu      Kaip sukurti duomenų srauto diagramą, kad būtų galima vizualizuoti bet kurio projekto duomenis  
Bet kurio proceso duomenų srautų diagramos (DFD) padeda suprasti, kaip duomenys teka iš šaltinio į paskirties vietą. Štai kaip jį sukurti!
Skaityti toliau   Susijusios temos  
 
Programavimas
 
„Java“
 
  Apie autorių   Joelis Lee(Paskelbti 1524 straipsniai)            
Joelis Lee yra „MakeUseOf“ vyriausiasis redaktorius nuo 2018 m. Jis turi B.S. įgijo informatikos ir daugiau nei devynerių metų profesionalaus rašymo ir redagavimo patirtį.
Kaip atsisiųsti roblox į chromebook
Daugiau iš Joel Lee
Prenumeruokite mūsų naujienlaiškį
 
Prisijunkite prie mūsų naujienlaiškio, kad gautumėte techninių patarimų, apžvalgų, nemokamų el. Knygų ir išskirtinių pasiūlymų!
Norėdami užsiprenumeruoti, spustelėkite čia