Programozás | Java, JSP » Schubert Tamás - A Java kivételkezelése

A Java kivételkezelése A program futása közben fellépő hibákat kezelni kell: 1. A programot olyan állapotba kell hozni, hogy folytatható legyen Azt kell tudnunk jelezni a programban, hogy mi történjék bizonyos hiba előfordulása esetén (a kivételes esemény kezelése), és hogy hol folytatódjék a program végrehajtása. Ezt akár többszörös metódushívás esetén is meg kell tudnunk tenni. Pl. ▪ Tömb indextúlcsordulás esetén egy nagyobb tömböt készítünk, az eredeti tömb elemeit átmásoljuk az új tömbbe, majd az eredeti tömböt megszüntetjük. Ezután folytatjuk a program végrehajtását. ▪ Grafikus kezelői felületet használva egy adatbeviteli mezőbe számot kell bekérnünk. Hibás adat bevitele esetén jelzést adunk, és az adat helyesbítéséig nem engedjük elhagyni az adatbeviteli mezőt. ▪ Fájlból adatokat olvasunk be a fájl végéig. Ha a fájl vége után is olvasni akarunk, hiba keletkezik. Ezt a várható hibát, amely

voltaképpen a beolvasás normális befejezését jelzi, kezelnünk kell, majd folytathatjuk a feldolgozást. 2. A kilépés előtt a tisztességes befejezés érdekében néhány dolgot el kell végezni A Java hibakezelése a kivételkezelésen alapszik (Exception) A kivétel olyan esemény, amely megszakítja a program normális futását, és kivételes módon fut tovább. A kivételt okozhat pl.: háttértároló megtelik, nullával osztunk, tömb indexhatárát túllépjük, illegális konverziót hajtunk végre, nem létező objektum metódusát hívjuk, verem megtelik, fájl vége után tovább olvasunk, fájl olvasása közben hiba keletkezik, a hivatkozott fájl nem létezik, stb. A kivételek kezelése is az osztályokon alapul. Ez a hiba típusától függő feldolgozást tesz lehetővé. A kivétel kezelése Hiba keletkezésekor a futó metódus, amelyben a hiba keletkezett, kiváltja a kivételt: throwing exception (kivétel kiváltása). Ekkor egy kivétel objektum jön

létre, amely információt tartalmaz a kivétel fajtájáról és a program állapotáról. Ezután ez az objektum a Java futtató környezet felügyelete alá kerül, amely eljuttatja a programnak arra a pontjára, ahol a kivétel lekezelhető. A kivétel keletkezésének módjai: 1. Futás közben rendellenes dolog történik (pl osztás 0-val) 2. A program egy throw utasítása váltja ki a kivételt (lehet a könyvtári csomagban vagy a saját osztályainkban) 3. Aszinkron kivétel lép fel, ha a program több szálon fut, és egy szál működése megszakad Az 1. bárhol, 2 és 3 a programnak csak meghatározott helyén léphet fel Ha egy metódus kiváltja az eseményt, a futása megszakad, és a vezérlés nem tér vissza a hiba keletkezésének helyére. -2Megfelelő kivételkezelő keresése A kivétel kiváltása után a JVM olyan helyet keres a programban, ahol a kivétel kezelése megtörténhet. A kivételt az a kivételkezelő kódblokk fogja lekezelni, amelynek a

hatókörében keletkezett, és amely megfelelő típusú. metódus metódus . . try { A kivételkezelő hatókörének kezdete Ehhez a blokkhoz rendelünk egy vagy több kivétel típust és kivételkezelő blokkot A kivételkezelő hatókörének vége . . } catch (kivétel típus1 változó1) {kivételkezelő blokk1} catch (kivétel típus2 változó2) {kivételkezelő blokk2} catch (kivétel típus3 változó3) {kivételkezelő blokk3} finally { utasítások } . . A kivételkezelő megfelelő típusú, ha az általa kezelt kivétel típusa azonos a kiváltott kivétel típusával vagy őse annak. A kivételkezelő hatókörét a programozó határozza meg. /* A String tömb adatait Integer tipusú tömbbe teszi. Nem ellenőrzött kivételek: NumberFormatException, NullPointerException. Elkapásuk vagy specifikálásuk nem kötelező! */ public class Kivetel1 { public static void main(String[] args) { String[] tk = {"12", "34", "a56",

"78", "90", "123"}; final int max = tk.length; Integer[] egesz = new Integer[max]; // Hibás adat esetén for (int j = 0; j < max; j++) { try { egesz[j] = new Integer(tk[j]); } catch (NumberFormatException nf) {System.outprintln(j + 1 + " adat hibás: " + tk[j]);} } // Kiírjuk az egesz tömb tartalmát for (int j = 0; j < max; j++) { try { System.outprintln(egesz[j]floatValue()); } catch (NullPointerException np) {System.outprintln(j + 1 + " elem nem létezik!");} } } } -3public class Kivetel2 { public static void main(String[] args) { String[] tk = {"12", "34", "a56", "78", "90", "123"}; final int max = tk.length; Integer[] egesz = new Integer[max]; try { for (int j = 0; j < max + 2; j++) { try { egesz[j] = new Integer(tk[j]); System.outprintln(egesz[j]floatValue()); } catch (NumberFormatException nf) { System.outprintln(j + 1 + " adat hibás: " +

tk[j]); } } } catch (ArrayIndexOutOfBoundsException tulcsordul) { System.outprintln(" Tömb megtelt!"); } } } import java.util*; public class Stackpelda { public static void main(String args[]) { Stack s = new Stack(); Float f; s.push(new Float(1)); // public Object push(Object item); s.push(new Float(2)); s.push(new Float(3)); s.push(new Float(4)); System.outprintln("Verem üres?: " + sempty()); // pop() használatakor EmptyStackException kivétel kiváltódhat try { while (true) { f = (Float) s.pop(); System.outprintln(f); } } catch (EmptyStackException ures) { System.outprintln("Verem kiürült!"); } } } -4Működési mód 1. A kivételkezelő hatókörében hiba lép fel, és egy, a hibának megfelelő típusú kivételobjektum keletkezik. (Ez a kivétel kiváltása) 2. A Java virtuális gép (JVM) megkeresi a megfelelő kivételkezelőt: − először megnézi, hogy a kiváltott kivétel típusa azonos-e vagy leszármazottja a kivétel

típus1-nek. Ha igen, akkor az ehhez tartozó kivételkezelő blokk kapja meg a vezérlést. − ha nem, akkor a kivétel típus2-vel, majd kivétel típus3-mal próbálkozik. 3. A kivételkezelő blokk végrehajtása után végrehajtja a finally blokk utasításait (ha van ilyen) 4. A program a catch, finally blokkok utáni utasítással folytatódik A try { } blokk végrehajtásának esetei 1. Nem lép fel hiba A finally blokk ekkor is végrehajtódik (ha van) 2. Hiba lép fel, és valamelyik catch ág lekezeli a hibát Ezután a finally blokk végrehajtódik (ha van). 3. Hiba lép fel, de nincs alkalmas kivételkezelő A finally blokk végrehajtódik, majd a hívó metódus kivételkezelőjének adódik át a vezérlés metódus1 . . metódus try { hívás . . . } catch ( ) {.} catch ( ) {.} . . metódus2 . . try { . . . } catch ( ) {.} catch ( ) {.} finally {.} . . alkalmas kivételkezelő keresése a hívó metódus hatókörében kivétel kiváltása nincs alkalmas

kivételkezelő finally végrehajtása A kivételkezelés alkalmazási köre A Java nyelvnek sok kivételtípusa van: pl. ArithmeticException, ArrayIndexOutOfBoundsException, NumberFormatException, EmptyStackException, EOFException, FileNotFoundException, IOException, NullPointerException A programozó saját típusokat hozhat létre. A kivételek alapvetően 2 csoportba oszthatók: 1. Ellenőrzött kivételek 2. Nem ellenőrzött kivételek Az ellenőrzött kivételeket: 1. Elkapni, vagy 2. Specifikálni kell, -5különben fordítási hiba lép fel. Azért vannak nem ellenőrzött kivételek is, mert vannak olyan hibák, amelyek szinte bárhol felléphetnek, kezelésük a Java nyelven belül lehetetlen. Ez csak gondot okozna a programozóknak. A kivételek specifikálása Az olyan ellenőrzött kivételeket, amelyeket a metódusban nem kapunk el, specifikálni kell: a metódus fejében ezeket felsoroljuk, jelezve, hogy a metódus hívásakor fel kell készülni ezek

elkapására. Pl. metódus () throws kivétel1, kivétel 2, { metódus törzs } Kivételek hiba keletkezésekor váltódnak ki, vagy throw utasítással is kiválthatók! import java.io*; public class Kivetel4 { public static void main(String [] args) { String [] tk = {"12", "34", "a56", "78", "90", "123"}; for (int i = 0; i < tk.length; i++) { System.outprintln(tk[i]); } FileWriter f = null; PrintWriter g = null; try { f = new FileWriter("adat.txt"); // IOException-t elkapni, vagy specifikálni kell! g = new PrintWriter(f, true); // throw new IOException(); } catch (IOException io) {System.outprintln(io + " File megnyitási hiba!"); System.exit(-1);} // Az adatokat file-ba menti try { kiir(g, tk); } catch (IOException io) {System.outprintln(io + " hiba"); } finally {g.close();} } // ---------------------------------------static void kiir (PrintWriter g, String [] tk) throws IOException { for

(int j = 0; j < tk.length; j++) { g.println(tk[j]); System.outprintln(tk[j]); if (j == 3) throw new IOException(); } } } -6Kivételosztályok java.lang Throwable a kiváltható osztályok hierarchiájának csúcsa. Ez és ennek a leszármazottjai a throw utasítással kiválthatók. komoly hiba esetén lép fel. Pl OutOfMemoryError (elfogyott a mermória). Ritkán fordulnak elő. Több leszármazottja van. Az Error leszármazottjai nem ellenőrzött kivételek. Ez, és ezek leszármazottai ellenőrzött kivételek (a RunTimeException kivételével). A program teljes hibakezelését lényegében az Exception és leszármazottai segítségével oldjuk meg. A saját kivétel osztályinkat is az Exception-ból célszerű származtatni. java.langError java.langException Object Throwable Error Exception RuntimeException Nem ellenőrzött Ellenőrzött Nem ellenőrzött -7A RuntimeException közvetlen leszármazottai: o class java.langRuntimeException o class

java.langArithmeticException o class java.langArrayStoreException o class java.langClassCastException o class java.langIllegalArgumentException o class java.langIllegalThreadStateException o class java.langNumberFormatException o class java.langIllegalMonitorStateException o class java.langIllegalStateException o class java.langIndexOutOfBoundsException o class java.langArrayIndexOutOfBoundsException o class java.langStringIndexOutOfBoundsException o class java.langNegativeArraySizeException o class java.langNullPointerException o class java.langSecurityException o class java.langUnsupportedOperationException -8Saját kivételosztály létrehozása class VeremMegteltException extends Exception { public int egesz; public VeremMegteltException(int egesz) { this.egesz = egesz; } } class verem { final static int MERET = 3; int mutato = 0; // mutato a következő szabad helyre mutat int[] verem = new int[MERET]; void betesz(int egesz) throws

VeremMegteltException { if (mutato < MERET) { verem[mutato++] = egesz; } else { throw new VeremMegteltException(egesz); } } } public class Kivetel6 { public static void main(String[] args) { // egészeket fogunk a verembe tenni verem v = new verem(); try { v.betesz(1); v.betesz(2); v.betesz(3); v.betesz(4); } catch (VeremMegteltException vm) { System.outprintln(vmegesz + " nem fér a verembe!"); } for (int i = 0; i < v.mutato; i++) { System.outprintln(vverem[i]); } } }