Útmutató a Java végre kulcsszóhoz

1. Áttekintés

Ebben az oktatóanyagban a végül kulcsszó Java-ban. Meglátjuk, hogyan kell használni mellette próbáld / fogd blokkok a hibakezelésben. Bár végül célja a kód végrehajtásának garantálása, megvitatjuk azokat a kivételes helyzeteket, amelyekben a JVM nem hajtja végre.

Megbeszélünk néhány gyakori buktatót is, ahol a végül blokk váratlan kimenetelű lehet.

2. Mi az végül?

végül meghatározza a kódblokkot, amelyet a próbáld ki kulcsszó. Meghatározza a kódot, amely mindig a. Után fut próbáld ki és bármelyik fogás blokk, mielőtt a módszer befejeződött.

A végül A blokk végrehajtása függetlenül attól, hogy kivételt dobtak vagy elkaptak.

2.1. Egy gyors példa

Nézzük végül a próbáld meg utolérni Blokk:

próbáld ki a {System.out.println ("A számlálás értéke" + Integer.parseInt (count)); } catch (NumberFormatException e) {System.out.println ("Nincs számolás"); } végül {System.out.println ("Végül be"); } 

Ebben a példában, függetlenül a paraméter értékétől számol, a JVM végrehajtja a végül blokk és nyomatok „Végül”.

2.2. Használata végül Nélkül fogás Blokk

Továbbá használhatjuk a végül blokkolja a próbáld ki blokkolja, függetlenül attól, hogy a fogás blokk van:

próbáld ki a {System.out.println ("Inside try"); } végül {System.out.println ("Végül bent"); }

És megkapjuk a kimenetet:

Inside próbáld meg Inside végül

2.3. Miért végül Hasznos

Általában a végül blokk a tisztító kód futtatásához, például a kapcsolatok bezárásához, a fájlok bezárásához vagy a szálak felszabadításához, mivel kivételektől függetlenül végrehajtja.

Jegyzet: az erőforrásokkal való próbálkozás az erőforrások bezárására is használható az a helyett végül Blokk.

3. Mikor végül Végrehajtva

Vessünk egy pillantást a JVM végrehajtásának összes permutációjára végül blokkok, így jobban megérthetjük.

3.1. Nem dobnak kivételt

Amikor az próbáld ki blokk elkészül, a végül a blokk akkor is végrehajtásra kerül, ha nem volt kivétel:

próbáld ki a {System.out.println ("Inside try"); } végül {System.out.println ("Végül bent"); }

Ebben a példában nem vetünk ki kivételt a próbáld ki Blokk. Így a JVM végrehajtja az összes kódot mindkét próbáld ki és végül blokkok.

Ez eredményezi:

Inside próbáld meg Inside végül

3.2. A kivételt eldobják és nem kezelik

Ha van kivétel, és nem fogják el, akkor a végül blokk még mindig végrehajtva:

próbáld ki a {System.out.println ("Inside try"); dobja az új Kivételt (); } végül {System.out.println ("Végül bent"); }

A JVM végrehajtja a végül blokk kezeletlen kivétel esetén is.

És a kimenet a következő lenne:

Inside próbáld meg Inside végül Kivétel a "main" szálban java.lang.Exception

3.3. Kivételt dobnak és kezelnek

Ha van kivétel, és a fogás blokk, a végül blokk még mindig végrehajtva:

próbáld ki a {System.out.println ("Inside try"); dobja az új Kivételt (); } catch (e kivétel) {System.out.println ("Belső fogás"); } végül {System.out.println ("Végül bent"); }

Ebben az esetben a fogás blokk kezeli a dobott kivételt, majd a JVM végrehajtja a végül blokkolja és előállítja a kimenetet:

Inside végül Inside catch Inside végül

3.4. A módszer visszatér próbáld ki Blokk

Még a módszerből való visszatérés sem akadályozza meg végül blokkok a futástól:

próbáld ki a {System.out.println ("Inside try"); visszatér "próbálkozásból"; } végül {System.out.println ("Végül bent"); }

Itt, annak ellenére, hogy a módszernek van egy Visszatérés utasítás, a JVM végrehajtja a végül blokkolja, mielőtt átadná a vezérlést a hívási módnak.

Megkapjuk a kimenetet:

Inside próbáld meg Inside végül

3.5. A módszer visszatér fogás Blokk

Amikor az fogás blokk tartalmazza a Visszatérés nyilatkozat, az végül blokk még mindig hívják:

próbáld ki a {System.out.println ("Inside try"); dobja az új Kivételt (); } catch (e kivétel) {System.out.println ("Belső fogás"); visszatérés a fogásból; } végül {System.out.println ("Végül bent"); }

Amikor kivételt vetünk a próbáld ki blokk, a fogás blokk kezeli a kivételt. Bár van egy visszatérési nyilatkozat a fogás blokk, a JVM végrehajtja a végül blokkolja, mielőtt átadná az irányítást a hívási módnak, és kimeneti:

Inside végül Inside catch Inside végül

4. Mikor végül Nincs végrehajtva

Bár mindig azt várjuk, hogy a JVM végrehajtja az a végül blokk, vannak olyan helyzetek, amikor a JVM nem hajtja végre a végül Blokk.

Arra számíthatunk már, hogy ha az operációs rendszer leállítja programunkat, akkor a programnak nem lesz esélye teljes kódjának végrehajtására. Van néhány olyan intézkedés is, amelyet hasonlóan megakadályozhatunk egy függőben lévő folyamat végrehajtásában végül Blokk.

4.1. Felhívás System.exit

Ebben az esetben a JVM-et hívással szüntetjük meg System.exit és ezért a JVM nem hajtja végre a mi végül Blokk:

próbáld ki a {System.out.println ("Inside try"); System.exit (1); } végül {System.out.println ("Végül bent"); }

Ez eredményezi:

Bent próbáld meg

4.2. Felhívás Állj

Hasonló System.exit, felhívás a következőre: Futásidejű.halt szintén leállítja a végrehajtást, és a JVM nem hajt végre semmit végül blokkok:

próbáld ki a {System.out.println ("Inside try"); Runtime.getRuntime (). Halt (1); } végül {System.out.println ("Végül bent"); }

Így a kimenet:

Bent próbáld meg

4.3. Démon szál

Ha egy Daemon szál belép a próbáld meg / végül A blokk és az összes többi nem démon szál kilép, mielőtt a démon szál végrehajtaná a végül blokk, a JVM nem várja meg, hogy a démon szál befejezze a végrehajtását végül Blokk:

Futható futható = () -> {try {System.out.println ("Inside try"); } végül {próbáld ki {Thread.sleep (1000); System.out.println ("Végül bent"); } catch (InterruptedException e) {e.printStackTrace (); }}}; Szál normál = új Szál (futható); Szál démon = new Szál (futtatható); daemon.setDaemon (true); rendszeres.indítás (); Szál.alszik (300); daemon.start ();

Ebben a példában a futható nyomatok „Inside try” amint belép a módszerbe és vár 1 másodpercet a nyomtatás előtt „Végül bent”.

Itt kezdjük a szabályos szál és a démon szál kis késéssel. Amikor az szabályos szál végrehajtja a végül blokk, a démon szál még mindig a próbáld ki Blokk. Mivel a szabályos szál befejezi a végrehajtást és kilép, a JVM is kilép, és nem várja meg a démon szál a végül Blokk.

Itt van a kimenet:

Inside próbáld meg Inside próbáld meg végre az Inside-t

4.4. A JVM egy végtelen hurkot ér el

Itt van egy próbáld ki blokk, amely egy végtelenet tartalmaz míg hurok:

próbáld ki a {System.out.println ("Inside try"); while (true) {}} végül {System.out.println ("Végül bent"); }

Bár nem kifejezetten erre vonatkozik végül, érdemes megemlíteni, hogy ha a próbáld ki vagy fogás blokk tartalmaz egy végtelen ciklust, a JVM soha nem fog elérni egyetlen blokkot sem azon a cikluson túl.

5. Gyakori csapdák

Van néhány gyakori buktató, amelyet el kell kerülnünk, amikor a végül Blokk.

Bár ez teljesen legális, rossz gyakorlatnak számít, ha van egy Visszatérés nyilatkozatot, vagy dobjon kivételt a végül Blokk, és mindenáron kerülnünk kell.

5.1. A kivételeket figyelmen kívül hagyja

A Visszatérés nyilatkozat a végül blokk figyelmen kívül hagy egy be nem fogott kivételt:

próbáld ki a {System.out.println ("Inside try"); dobja új RuntimeException (); } végül {System.out.println ("Végül bent"); visszatér "végre"; }

Ebben az esetben a módszer figyelmen kívül hagyja a RuntimeException dobja és visszaadja az értéket „Végre”.

5.2. Figyelmen kívül hagyja az Egyéb elemet Visszatérés Nyilatkozatok

A Visszatérés nyilatkozat a végül blokk figyelmen kívül hagy minden más visszatérési utasítást a próbáld ki vagy fogás Blokk. Csak a Visszatérés nyilatkozat a végül blokk végrehajtja:

próbáld ki a {System.out.println ("Inside try"); visszatér "próbálkozásból"; } végül {System.out.println ("Végül bent"); visszatér "végre"; }

Ebben a példában a módszer mindig visszatér „Végre” és teljesen figyelmen kívül hagyja a Visszatérés nyilatkozat a próbáld ki Blokk. Ez nagyon nehezen észlelhető hiba lehet, ezért kerülnünk kell a felhasználást Visszatérés ban ben végül blokkok.

5.3. Megváltoztatja a dobott vagy visszaküldött elemeket

Továbbá abban az esetben, ha dobnak egy kivételt a végül blokkolja, a módszer figyelmen kívül hagyja a dobott kivételt vagy Visszatérés nyilatkozatok a próbáld ki és fogás blokkok:

próbáld ki a {System.out.println ("Inside try"); visszatér "próbálkozásból"; } végül {dobjon új RuntimeException (); }

Ez a módszer soha nem ad vissza értéket, és mindig a-t dobja RuntimeException.

Bár lehet, hogy szándékosan nem vetünk ki kivételt a végül blokkolja, mint ebben a példában, még mindig találkozhatunk ezzel a problémával. Akkor fordulhat elő, ha az a végül blokkdobás kivétel.

6. Következtetés

Ebben a cikkben megvitattuk, mit végül blokkok nem a Java-ban és hogyan kell használni őket. Ezután különböző eseteket vizsgáltunk, amikor a JVM végrehajtja őket, és néhányat, amikor nem.

Végül megvizsgáltunk néhány gyakori buktatót a használatsal kapcsolatban végül blokkok.

Mint mindig, az oktatóanyagban használt forráskód is elérhető a GitHubon.