A Java kivételek helyes kezelése

IllegalArgumentException
Ahhoz, hogy elkapja ezt a kivételt, el kell mennie hová
someMethod()
hívják és használja a try-catch blokk :
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Minden a próbáld ki blokk sorrendben fog végrehajtani, amíg kivételt nem dob. Amint kivételt dob, minden későbbi utasítást kihagy, és az alkalmazás logikája azonnal a fogás Blokk.
 
Példánkban belépünk a try blokkba és azonnal hívunk
someMethod()
. Mivel a 200 nem 0 és 100 között van, an
IllegalArgumentException
dobják. Ezzel azonnal véget ér a végrehajtása
someMethod()
, kihagyja a többi logikát a try blokkban (
someOtherMethod()
soha nem hívják meg), és folytatja a végrehajtást a fogási blokkon belül.
 
Mi történne, ha felhívnánk
someMethod(50)
helyette? Az
IllegalArgumentException
soha nem dobnák el.
someMethod()
normálisan hajtaná végre. A try blokk a szokásos módon, hívásként futna
someOtherMethod()
amikor a someMethod () befejeződik. Amikor
someOtherMethod()
véget ér, a fogási blokk kihagyásra kerül és
callingMethod()
folytatódna.
 
Ne feledje, hogy próbálkozási blokkonként több fogási blokk is lehet:
public void callingMethod() {  
 try {  
 someMethod(200);  
 someOtherMethod();  
 } catch (IllegalArgumentException e) {  
 // handle the exception in here  
 } catch (NullPointerException e) {  
 // handle the exception in here  
 }  
 // ...  
}
Azt is vegye figyelembe, hogy opcionális végül blokk is létezik:
public void method() {  
 try {  
 // ...  
 } catch (Exception e) {  
 // ...  
 } finally {  
 // ...  
 }  
}
A végső blokkon belüli kód az mindig kivégezték bármit is. Ha van egy visszatérési utasítás a try blokkban, akkor a végső blokk végrehajtásra kerül, mielőtt visszatér a metódusból. Ha újabb kivételt dob ​​a fogási blokkba, a végső blokk végrehajtódik, mielőtt a kivétel eldobásra kerül.
 
Az utolsó blokkot akkor kell használni, ha olyan objektumok vannak, amelyeket meg kell tisztítani a módszer befejezése előtt. Például, ha megnyitott egy fájlt a try blokkban, és később kivételt dobott, az utolsó blokk lehetővé teszi a fájl bezárását, mielőtt elhagyja a módszert.
 
Ne feledje, hogy végül blokkot kaphat fogási blokk nélkül:
public void method() {  
 try {  
 // ...  
 } finally {  
 // ...  
 }  
}
Ez lehetővé teszi a szükséges tisztítást, miközben lehetővé teszi, hogy a kivetett kivételek továbbítsák a metódus meghívási veremét (azaz itt nem szeretné kezelni a kivételt, de először is tisztítania kell).
 
Ellenőrzött és nem jelölt kivételek a Java -ban
A legtöbb nyelvvel ellentétben a Java különbséget tesz ellenőrzött kivételek és ellenőrizetlen kivételek (pl. a C# csak ellenőrizetlen kivételeket tartalmaz). Ellenőrzött kivétel kell abban a metódusban, ahol a kivételt dobja, különben a kód nem lesz fordítva.
 
Ellenőrzött kivétel létrehozásához nyissa meg a következőt:
Exception
. Ellenőrizetlen kivétel létrehozásához nyissa meg a következőt:
RuntimeException
.
 
Bármely metódusnak, amely ellenőrzött kivételt dob, ezt meg kell jelölnie a metódus aláírásban a dob kulcsszó. Mivel a Java beépített
IOException
bejelölt kivétel, a következő kód nem lesz lefordítva:
public void wontCompile() {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Először ki kell jelentenie, hogy ellenőrzött kivételt eredményez:
public void willCompile() throws IOException {  
 // ...  
 if (someCondition) {  
 throw new IOException();  
 }  
 // ...  
}
Ne feledje, hogy egy módszer kivételt dobhat, de valójában soha nem dobhat kivételt. Ennek ellenére a kivételt továbbra is el kell fogni, különben a kód nem lesz lefordítva.
 
Mikor használjon ellenőrzött vagy nem ellenőrzött kivételeket?
 
A hivatalos Java dokumentáció a oldal ebben a kérdésben . Ez a különbség egy tömör ökölszabály szerint foglalható össze: „Ha ésszerűen elvárható, hogy az ügyfél felépüljön egy kivételből, tegye azt ellenőrzött kivételnek. Ha az ügyfél nem tud semmit tenni a kivételből való helyreállítás érdekében, tegye azt ellenőrizetlen kivételnek. '
 
De ez az útmutató elavult lehet. Egyrészt az ellenőrzött kivételek robusztusabb kódot eredményeznek. Másrészt egyetlen más nyelv sem ellenőrizte a kivételeket ugyanúgy, mint a Java, ami két dolgot mutat: egyrészt a funkció nem elég hasznos ahhoz, hogy más nyelvek ellopják, és kettő, ezek nélkül is élhet. Ráadásul az ellenőrzött kivételek nem játszanak szépen a Java 8 -ban bevezetett lambda kifejezésekkel.
 
Irányelvek a Java kivételek használatához
 
A kivételek hasznosak, de könnyen visszaélnek és visszaélnek. Íme néhány tipp és bevált gyakorlat, amelyek segítenek elkerülni a rendetlenséget.
 
 
  Előnyben részesítse a konkrét kivételeket az általános kivételekkel szemben. Használja | _+_ | vége | _+_ | ha lehetséges, különben használja | _+_ | vége | _+_ | amikor lehetséges.
 
  Soha ne fogd | _+_ | ! A | _+_ | osztály valójában kiterjed | _+_ | , és a fogási blokk ténylegesen működik a | _+_ | vagy bármely olyan osztály, amely kiterjeszti a Dobható -t. Azonban a | _+_ | osztály is kiterjed | _+_ | , és soha nem akar elkapni egy | _+_ | mert | _+_ | s súlyos helyrehozhatatlan problémákat jeleznek.
 
  Soha ne fogd | _+_ | ! | _+_ | kiterjed | _+_ | , tehát minden blokk, amely elkapja | _+_ | fog is | _+_ | , és ez egy nagyon fontos kivétel, amellyel nem akarsz összezavarodni (különösen többszálú alkalmazásokban), ha nem tudod, mit csinálsz. Ha nem tudja, melyik kivételt kell elkapnia, fontolja meg, hogy ne fogjon semmit.
 
  Használjon leíró üzeneteket a hibakeresés megkönnyítésére. Ha kivételt dob, megadhat egy | _+_ | üzenet érvként. Ez az üzenet a fogási blokkban érhető el a | _+_ | használatával módszer, de ha a kivételt soha nem sikerül elkapni, akkor az üzenet a veremkövetés részeként is megjelenik.
 
  Próbálja meg nem elkapni és figyelmen kívül hagyni a kivételeket. Az ellenőrzött kivételek okozta kellemetlenségek elkerülése érdekében sok kezdő és lusta programozó beállít egy fogási blokkot, de üresen hagyja. Rossz! Mindig kecsesen bánj vele, de ha nem tudod, legalább nyomd ki a verem nyomait, hogy tudd, a kivételt eldobták. Ezt a | _+_ | gombbal teheti meg módszer.
 
  Óvakodjon a kivételek túlzott használatától. Ha van kalapácsod, minden úgy néz ki, mint egy szög. Amikor először megtudja a kivételeket, úgy érezheti, kötelessége mindent kivételnek alakítani ... arra a pontra, ahol az alkalmazás vezérlőfolyamatainak nagy része a kivételkezelésre vonatkozik. Ne feledje, a kivételek a „kivételes” eseményekre vonatkoznak!
 
 
Most már elég kényelmesnek kell lennie a kivételekkel, hogy megértse, mik ezek, miért használják őket, és hogyan illessze be őket saját kódjába. Ha nem teljesen érted a fogalmat, akkor semmi baj! Beletelt egy kis időbe, mire „kattanni” kezdett a fejemben, úgyhogy ne érezd úgy, hogy el kell sietned. Nem kell kapkodni.
 
  Van kérdése? Tud más kivételekkel kapcsolatos tippeket, amelyeket kihagytam? Ossza meg őket az alábbi megjegyzésekben!  
  Részvény    Részvény      Csipog      Email      Hogyan készítsünk adatáramlási diagramot bármely projekt adatainak megjelenítéséhez  
Bármely folyamat adatáramlási diagramjai (DFD) segítenek megérteni, hogyan folynak az adatok a forrásból a célállomásba. Így hozhat létre!
Olvassa tovább   Kapcsolódó témák  
 
Programozás
 
Jáva
 
  A szerzőről   Joel Lee(1524 megjelent cikk)            
Joel Lee a MakeUseOf főszerkesztője 2018 óta. B.S. számítástechnika szakon és több mint kilenc éves szakmai írási és szerkesztési tapasztalat.
rajzoljon szimbólumot
Továbbiak Joel Lee -től
Iratkozzon fel hírlevelünkre
 
Csatlakozz hírlevelünkhöz, ahol technikai tippeket, értékeléseket, ingyenes e -könyveket és exkluzív ajánlatokat találsz!
Feliratkozáshoz kattintson ide