it-swarm-eu.dev

Má konečně blok vždy popraven v jazyce Java?

S ohledem na tento kód mohu být naprosto jistý že finally blok se vždy provede bez ohledu na to, co je something()?

try {  
    something();  
    return success;  
}  
catch (Exception e) {   
    return failure;  
}  
finally {  
    System.out.println("I don't know if this will get printed out");
}
2159
jonny five

Ano, finally bude voláno po provedení kódových bloků try nebo catch.

Jediné časy finally nebudou volány jsou:

  1. Pokud vyvoláte System.exit()
  2. Pokud první JVM selže
  3. Pokud JVM dosáhne nekonečné smyčky (nebo nějakého jiného nepřerušitelného, ​​nekončícího příkazu) v bloku try nebo catch
  4. Pokud OS násilně ukončí proces JVM; např. kill -9 <pid> v systému UNIX
  5. Pokud systém Host zemře; např. výpadek napájení, hardwarová chyba, OS panika a další
  6. Pokud bude blok finally prováděn podprocesem démona a všechny ostatní podprocesy nepodléhající démonu, budou ukončeny před voláním finally
2415
jodonnell

Příklad kódu:

public static void main(String[] args) {
    System.out.println(Test.test());
}

public static int test() {
    try {
        return 0;
    }
    finally {
        System.out.println("finally trumps return.");
    }
}

Výstup:

finally trumps return. 
0
502
Kevin

I když je to špatná praxe, pokud existuje příkaz return v rámci posledního bloku, bude to trumfovat jakýkoli jiný návrat z regulárního bloku. To znamená, že následující blok by vrátil hodnotu false:

try { return true; } finally { return false; }

Stejná věc s výjimkami z posledního bloku.

362
MooBob42

Zde jsou oficiální slova z specifikace jazyka Java.

14.20.2. Spuštění try-ultimate a try-catch-konečně

Příkaz try s blokem finally je proveden prvním provedením bloku try. Pak existuje volba:

  • Pokud se provedení bloku try dokončí normálně, [...]
  • Pokud se provedení try bloku náhle ukončí z důvodu throw hodnoty V, [...]
  • Je-li provedení bloku try náhle dokončeno pro jakýkoli jiný důvod R, pak je proveden blok finally. Pak existuje volba:
    • Pokud se poslední blok dokončí normálně, příkaz try se náhle dokončí z důvodu R.
    • Pokud se blok finally dokončí neočekávaně z důvodu S, příkaz try se náhle dokončí pro důvod S ( a důvod R je vyřazen ).

Specifikace parametru return tento explicitně činí:

JLS 14.17 Prohlášení o návratu

ReturnStatement:
     return Expression(opt) ;

Příkaz return bez příkazu Expression pokouší přenést kontrolu na invoker metody nebo konstruktoru, který ji obsahuje.

Příkaz return s Expression pokouší přenést řízení na invoker metody, která ho obsahuje; hodnota Expression se stane hodnotou vyvolání metody.

Předchozí popisy říkají " pokusy k řízení přenosu" spíše než jen "transfer control" protože pokud existují nějaké try příkazy v rámci metody nebo konstruktoru, jejichž try bloky obsahují příkaz return, pak budou všechny finally klauzule těchto try příkazů provedeny v pořadí, které je nejvzdálenější než nejvzdálenější, předtím, než je řízení přeneseno na invoker metody nebo konstruktoru. Náhlé dokončení klauzule finally může narušit přenos řízení iniciovaný příkazem return.

249

Kromě ostatních odpovědí je důležité zdůraznit, že 'konečně' má právo potlačit jakoukoli výjimku/vrácenou hodnotu blokem try..catch. Následující kód například vrátí hodnotu 12:

public static int getMonthsInYear() {
    try {
        return 10;
    }
    finally {
        return 12;
    }
}

Podobně následující metoda nevyvolá výjimku:

public static int getMonthsInYear() {
    try {
        throw new RuntimeException();
    }
    finally {
        return 12;
    }
}

I když ji následující metoda hodí:

public static int getMonthsInYear() {
    try {
        return 12;          
    }
    finally {
        throw new RuntimeException();
    }
}
148
Eyal Schneider

Vyzkoušel jsem výše uvedený příklad s mírnou úpravou -

public static void main(final String[] args) {
    System.out.println(test());
}

public static int test() {
    int i = 0;
    try {
        i = 2;
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
    }
}

Výše uvedené výstupy kódu:

nakonec se vrátí.
2

Je to proto, že když je return i; provedeno, i má hodnotu 2. Po provedení tohoto finally bloku je provedeno, kde je 12 přiřazeno i a pak je provedeno System.out out.

Po provedení bloku finally blok try vrátí hodnotu 2 namísto vrácení 12, protože tento příkaz return není znovu proveden.

Budete-li ladit tento kód v Eclipse, pak budete mít pocit, že po provedení System.outfinally bloku je příkaz returntry blokován znovu. Ale to tak není. Jednoduše vrátí hodnotu 2.

109
vibhash

Zde je zpracování Kevinovy ​​odpovědi . Je důležité vědět, že výraz, který má být vrácen, je vyhodnocen před finally, i když je vrácen po.

public static void main(String[] args) {
    System.out.println(Test.test());
}

public static int printX() {
    System.out.println("X");
    return 0;
}

public static int test() {
    try {
        return printX();
    }
    finally {
        System.out.println("finally trumps return... sort of");
    }
}

Výstup:

X
finally trumps return... sort of
0
95
WoodenKitty

To je celá myšlenka konečného bloku. To vám umožní ujistit se, že budete dělat čištění, které by jinak mohly být přeskočeny, protože se vrátíte, mimo jiné, samozřejmě.

Nakonec se zavolá bez ohledu na to, co se stane v bloku try ( pokud zavoláte System.exit(int) nebo Java Virtual Machine z nějakého jiného důvodu nevyjde).

52
Chris Cooper

Logickým způsobem, jak o tom přemýšlet, je:

  1. Kód umístěný v konečném bloku musí být proveden bez ohledu na to v rámci zkušebního bloku
  2. Pokud se tedy kód v bloku pokusu pokusí vrátit hodnotu nebo vrátit výjimku, položka se umístí na „polici“, dokud nebude možné provést poslední blok.
  3. Protože kód v konečném bloku má (podle definice) vysokou prioritu, může se vrátit nebo hodit, co se mu líbí. V takovém případě je všechno, co zůstalo na polici, vyřazeno.
  4. Jedinou výjimkou je, že VM se během bloku pokusu úplně vypne, např. od „System.exit“
38
Garth Gilmour

nakonec je vždy proveden, pokud nenastane abnormální ukončení programu (např. volání System.exit (0) ..). tak, váš sysout bude vytištěn

18
shyam

Také návrat v konečném důsledku vyhodí všechny výjimky. http://jamesjava.blogspot.com/2006/03/dont-return-in-finally-clause.html

18

Konečný blok je vždy prováděn, pokud nedojde k abnormálnímu ukončení programu, a to buď v důsledku havárie JVM, nebo z volání System.exit(0).

Kromě toho, jakákoliv hodnota vrácená v rámci konečného bloku přepíše hodnotu vrácenou před provedením posledního bloku, takže buďte opatrní při kontrole všech výstupních bodů při použití pokusu nakonec.

17
user9189

Ne, ne vždy jedna výjimka je // System.exit (0); předtím, než konečný blok zabrání konečnému provedení.

  class A {
    public static void main(String args[]){
        DataInputStream cin = new DataInputStream(System.in);
        try{
            int i=Integer.parseInt(cin.readLine());
        }catch(ArithmeticException e){
        }catch(Exception e){
           System.exit(0);//Program terminates before executing finally block
        }finally{
            System.out.println("Won't be executed");
            System.out.println("No error");
        }
    }
}
17
Rajendra Jadi

Konečně je vždy spuštěn, to je celý bod, jen proto, že se objeví v kódu po návratu neznamená, že je to tak, jak je implementován. Běhový modul Java je zodpovědný za spuštění tohoto kódu při opuštění bloku try.

Například pokud máte následující:

int foo() { 
    try {
        return 42;
    }
    finally {
        System.out.println("done");
    }
}

Runtime vygeneruje něco takového:

int foo() {
    int ret = 42;
    System.out.println("done");
    return 42;
}

Pokud je vyvolána nepozorovaná výjimka, spustí se blok finally a výjimka bude pokračovat v šíření.

12
Motti

Je to proto, že jste přiřadili hodnotu i jako 12, ale funkci vrací funkci i nevrátili. Správný kód je následující:

public static int test() {
    int i = 0;
    try {
        return i;
    } finally {
        i = 12;
        System.out.println("finally trumps return.");
        return i;
    }
}
10
Wasim

Protože nakonec bude vždy zavolán blok, pokud nezavoláte System.exit() (nebo podproces selže).

9
Jay Riggs

Odpověď je jednoducháANO.

VSTUP:

try{
    int divideByZeroException = 5 / 0;
} catch (Exception e){
    System.out.println("catch");
    return;    // also tried with break; in switch-case, got same output
} finally {
    System.out.println("finally");
}

VÝSTUP:

catch
finally
9
Meet

Ano, zavolá. To je celý smysl mít konečně klíčové slovo. Pokud skákání z bloku try/catch by mohlo přeskočit nakonec blok, bylo to stejné jako vložení System.out.println mimo try/catch.

8
Mendelt

Ano, nakonec se vždy provede blok. Většina vývojářů používá tento blok pro uzavření databázového připojení, objektu resultset, objektu object a také do režimu spánku v jazyce Java pro vrácení transakce.

8
Gautam Viradiya

Stručně řečeno, v oficiální dokumentaci Java (Click zde ) je napsáno, že -

Pokud JVM skončí, zatímco je prováděn kód try nebo catch, pak se konečný blok nemusí spustit. Podobně platí, že pokud je vlákno provádějící kód pokusu nebo úlovku přerušeno nebo zabito, blok se nakonec nemůže spustit, i když aplikace jako celek pokračuje.

8
bikz05

Ano, bude. Pouze v případě, že to nebude, JVM ukončí nebo havaruje

7
abhig

Ano, bude. Nezáleží na tom, co se děje ve vašem pokusu nebo blokování, pokud jinak System.exit () volal nebo JVM havaroval. pokud je v bloku (blocích) nějaký příkaz return, bude nakonec proveden před tímto příkazem.

7
Karthikeyan

Zvažte následující program:

public class SomeTest {

    private static StringBuilder sb = new StringBuilder();

    public static void main(String args[]) {

        System.out.println(someString());
        System.out.println("---AGAIN---");
        System.out.println(someString());
        System.out.println("---PRINT THE RESULT---");
        System.out.println(sb.toString());
    }

    private static String someString() {

        try {
            sb.append("-abc-");
            return sb.toString();

        } finally {
            sb.append("xyz");
        }
    }
}

Jako u Java 1.8.162 poskytuje výše uvedený kódový výstup následující výstup:

-abc-
---AGAIN---
-abc-xyz-abc-
---PRINT THE RESULT---
-abc-xyz-abc-xyz

to znamená, že použití finally k uvolnění objektů je dobrý postup jako následující kód:

private static String someString() {

    StringBuilder sb = new StringBuilder();

    try {
        sb.append("abc");
        return sb.toString();

    } finally {
        sb = null; // Just an example, but you can close streams or DB connections this way.
    }
}
7
Samim

Zkoušel jsem to, je to jeden závit.

class Test {
    public static void main(String args[]) throws Exception {
       Object obj = new Object();
       try {
            synchronized (obj) {
            obj.wait();
            System.out.println("after wait()");
           }
       } catch (Exception e) {
       } finally {
           System.out.println("finally");
       }
   }
}

Hlavní vlákno bude navždy na stavu čekání, proto se nakonec nikdy nebude volat,

takže výstup konzoly nebude tisknout řetězec: after wait() nebo finally

S výše uvedeným příkladem @Stephen C je jeden z 3. případových jmen zde :

Přidání několika dalších možností nekonečné smyčky v následujícím kódu:

// import Java.util.concurrent.Semaphore;
class Test {
    public static void main(String[] args) {
        try {
            // Thread.sleep(Long.MAX_VALUE);
            // Thread.currentThread().join();
            // new Semaphore(0).acquire();
            // while (true){}
            System.out.println("after sleep join semaphore exit infinite while loop");
        } catch (Exception e) {
        } finally {
            System.out.println("finally");
        }
    }
}

Případ 2: Pokud první JVM selže

import Sun.misc.Unsafe;
import Java.lang.reflect.Field;
class Test {
    public static void main(String args[]) {
        try {
            unsafeMethod();
//            Runtime.getRuntime().halt(123);
            System.out.println("After Jvm Crash!");
        } catch (Exception e) {
        } finally {
            System.out.println("finally");
        }
    }

    private static void unsafeMethod() throws NoSuchFieldException, IllegalAccessException {
        Field f = Unsafe.class.getDeclaredField("theUnsafe");
        f.setAccessible(true);
        Unsafe unsafe = (Unsafe) f.get(null);
        unsafe.putAddress(0, 0);
    }
}

Ref: Jak havarujete JVM?

Případ 6: Pokud bude konečně blok prováděn podprocesem démon a všechny ostatní podprocesy nepodléhající démonu, bude ukončen dříve, než bude zavolán.

class Test {
    public static void main(String args[]) {
        Runnable runnable = new Runnable() {
            @Override
            public void run() {
                try {
                    printThreads("Daemon Thread printing");
                    // just to ensure this thread will live longer than main thread
                    Thread.sleep(10000);
                } catch (Exception e) {
                } finally {
                    System.out.println("finally");
                }
            }
        };
        Thread daemonThread = new Thread(runnable);
        daemonThread.setDaemon(Boolean.TRUE);
        daemonThread.setName("My Daemon Thread");
        daemonThread.start();
        printThreads("main Thread Printing");
    }

    private static synchronized void printThreads(String str) {
        System.out.println(str);
        int threadCount = 0;
        Set<Thread> threadSet = Thread.getAllStackTraces().keySet();
        for (Thread t : threadSet) {
            if (t.getThreadGroup() == Thread.currentThread().getThreadGroup()) {
                System.out.println("Thread :" + t + ":" + "state:" + t.getState());
                ++threadCount;
            }
        }
        System.out.println("Thread count started by Main thread:" + threadCount);
        System.out.println("-------------------------------------------------");
    }
}

output: Toto nevytiskne "konečně", což znamená, že "Konečně blok" v "démonovém vláknu" se nespustil

main Thread Printing  
Thread :Thread[My Daemon Thread,5,main]:state:BLOCKED  
Thread :Thread[main,5,main]:state:RUNNABLE  
Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE   
Thread count started by Main thread:3  
-------------------------------------------------  
Daemon Thread printing  
Thread :Thread[My Daemon Thread,5,main]:state:RUNNABLE  
Thread :Thread[Monitor Ctrl-Break,5,main]:state:RUNNABLE  
Thread count started by Main thread:2  
-------------------------------------------------  

Process finished with exit code 0
6
dkb

Ano, protože žádný kontrolní příkaz může zabránit provedení finally.

Zde je referenční příklad, kde budou provedeny všechny bloky kódu:

| x | Current result | Code 
|---|----------------|------ - - -
|   |                |     
|   |                | public static int finallyTest() {
| 3 |                |     int x = 3;
|   |                |     try {
|   |                |        try {
| 4 |                |             x++;
| 4 | return 4       |             return x;
|   |                |         } finally {
| 3 |                |             x--;
| 3 | throw          |             throw new RuntimeException("Ahh!");
|   |                |         }
|   |                |     } catch (RuntimeException e) {
| 4 | return 4       |         return ++x;
|   |                |     } finally {
| 3 |                |         x--;
|   |                |     }
|   |                | }
|   |                |
|---|----------------|------ - - -
|   | Result: 4      |

Ve variantě níže bude return x; přeskočeno. Výsledek je stále 4:

public static int finallyTest() {
    int x = 3;
    try {
        try {
            x++;
            if (true) throw new RuntimeException("Ahh!");
            return x; // skipped
        } finally {
            x--;
        }
    } catch (RuntimeException e) {
        return ++x;
    } finally {
        x--;
    }
}

Reference samozřejmě sledují jejich stav. Tento příklad vrací odkaz s value = 4:

static class IntRef { public int value; }
public static IntRef finallyTest() {
    IntRef x = new IntRef();
    x.value = 3;
    try {
        return x;
    } finally {
        x.value++; // will be tracked even after return
    }
}
6
Dávid Horváth

finally bude provedeno a to je jisté.

finally se nespustí v níže uvedených případech:

případ 1:

Při provádění System.exit().

případ 2:

Když váš JVM/Thread havaruje.

případ 3:

Při ručním zastavení provádění.

6
Utkash Bhatt

try- catch- finally jsou klíčová slova pro použití případu zpracování výjimek.
Jako normální vysvětlení

try {
     //code statements
     //exception thrown here
     //lines not reached if exception thrown
} catch (Exception e) {
    //lines reached only when exception is thrown
} finally {
    // always executed when the try block is exited
    //independent of an exception thrown or not
}

Blok konečně zabraňuje spuštění ...

  • Když jste nazvali System.exit(0);
  • Pokud JVM opustí.
  • Chyby v JVM
6

Pokud nezvládnete výjimku, před ukončením programu provede JVM nakonec blokování. Neprovede se pouze v případě, že normální provedení programu nepovede k ukončení programu z následujících důvodů:.

  1. Tím, že způsobí fatální chybu, která způsobí, že proces přerušení.

  2. Ukončení programu z důvodu poškození paměti.

  3. Voláním System.exit ()

  4. Pokud program přejde do nekonečné smyčky.

6

To je ve skutečnosti pravda v jakémkoli jazyce ... nakonec se vždy provede před návratem prohlášení, bez ohledu na to, kde je návrat v těle metody. Kdyby tomu tak nebylo, konečný blok by neměl velký význam.

6
Scott Dorman

Přidání @ vibhash odpověď jak žádná jiná odpověď vysvětluje, co se děje v případě mutable objektu, jako je ten níže.

public static void main(String[] args) {
    System.out.println(test().toString());
}

public static StringBuffer test() {
    StringBuffer s = new StringBuffer();
    try {
        s.append("sb");
        return s;
    } finally {
        s.append("updated ");
    }
}

Bude výstup

sbupdated 
6

Ano, je napsáno zde

Pokud JVM skončí, zatímco je prováděn kód try nebo catch, pak se konečný blok nemusí spustit. Podobně platí, že pokud je vlákno provádějící kód pokusu nebo úlovku přerušeno nebo zabito, blok se nakonec nemůže spustit, i když aplikace jako celek pokračuje.

5

Kromě bodu o návratu v konečném nahrazení návratu ve zkušebním bloku platí to samé o výjimce. Nakonec blok, který vyvolá výjimku, nahradí návrat nebo výjimku, která byla vyvolána z bloku pokusu.

5
Alex Miller

NE VŽDY

Specifikace jazyka Java popisuje, jak try-catch-final a try-catch blokují práci na 14.20.2
V žádném případě neuvádí, že se nakonec provede vždy poslední blok. Ale pro všechny případy, ve kterých jsou bloky try-catch-final a try-konečně dokončeny, musí být před provedením dokončeno.

try {
  CODE inside the try block
}
finally {
  FIN code inside finally block
}
NEXT code executed after the try-finally block (may be in a different method).

JLS nezaručuje, že FIN je provedeno po K&OACUTE;D. JLS zaručuje, že pokud jsou provedeny K&OACUTE;D a DAL&SCARON;&IACUTE;, pak FIN bude vždy provedeno po K&OACUTE;D a před DAL&SCARON;&IACUTE;.

Proč JLS nezaručuje, že se po bloku pokusu vždy provede poslední blok? Protože je to nemožné. Je nepravděpodobné, ale možné, že JVM bude přerušen (zabít, spadnout, vypnout) těsně po dokončení bloku pokusu, ale před provedením konečného bloku. JLS nemůže nic udělat, aby se tomu vyhnula.

Takže jakýkoliv software, který pro své správné chování závisí na konečných blocích, které jsou vždy prováděny po dokončení jejich zkušebních bloků.

Vrácení v bloku pokusu je pro tento problém irelevantní. Pokud provedení dosáhne kódu poté, co je try-catch-nakonec zaručeno, že poslední blok bude proveden dříve, s nebo bez vrácení uvnitř bloku try.

Konečný blok nebude volán po návratu v několika jedinečných scénářích: pokud je System.exit () volán jako první, nebo pokud dojde k chybě JVM.

Pokusím se odpovědět na vaši otázku nejjednodušším možným způsobem.

Pravidlo 1 : Konečný blok je vždy spuštěn (i když z něj existují výjimky. Ale držme se toho ještě někdy.)

Pravidlo 2 : příkazy v konečném bloku se spustí, když řízení opustí pokus nebo blokování. Převod řízení může nastat v důsledku normálního provedení, provedení přestávky, pokračování, goto nebo nebo prohlášení o výjimce.

V případě příkazu return specificky (od jeho titulku) musí ovládací prvek opustit volací metodu, a proto volá konečný blok odpovídající struktury try-final. Příkaz return je proveden po posledním bloku.

V případě, že je v bloku konečně také příkaz return, bude to určitě přepsáno před příkazem, který se čeká na bloku try, od jeho vymazání zásobníku volání.

Lepší vysvětlení naleznete zde: http://msdn.Microsoft.com/en-us/ .... koncept je většinou stejný ve všech jazycích na vysoké úrovni.

5
Sandip Solanki
  1. Nakonec Block vždy popraven. Pokud a dokud neexistuje System.exit () příkaz existuje (první příkaz v konečném bloku).
  2. Je-li system.exit () je první příkaz, pak konečně blok nebude proveden a kontrola vyjde z posledního bloku. Kdykoliv se příkaz System.exit () dostane nakonec do bloku, dokud tento příkaz nakonec nezačne fungovat, a když se objeví System.exit (), pak řídicí síla zcela vyjde z konečného bloku.
5
Avinash Pande

Stejný jako následující kód:

static int f() {
    while (true) {
        try {
            return 1;
        } finally {
            break;
        }
    }
    return 2;
}

f se vrátí 2!

4
dibo

Protože finále je vždy voláno ve všech případech, které máte. Nemáte výjimku, je stále volána, výjimka chytit, je stále volána

4
vodkhang

Ano bude vždy volána, ale v jedné situaci není volání při použití System.exit ()

try{
//risky code
}catch(Exception e){
//exception handling code
}
finally(){
//It always execute but before this block if there is any statement like System.exit(0); then this block not execute.
}
4

Nakonec blok vždy provede, zda se jedná o výjimku nebo ne. Pokud se vyskytla nějaká výjimka před pokusem o blok, pak se nakonec blok nespustí.

4
Rohit Chugh

Pokud je vyvolána výjimka, konečně běží. Pokud není výjimka vyvolána, konečně běží. Pokud je výjimka zachycena, spustí se nakonec. Pokud není výjimka zachycena, spustí se.

Je-li JVM ukončen, je pouze čas neběží.

4
Bhushan

Uvažujme o tom v normálním průběhu provádění (tj. Bez házení jakékoli výjimky): pokud metoda není „neplatná“, pak vždy explicitně vrátí něco, ale nakonec se vždy provede

4
Gala101

Vyzkoušejte tento kód, budete rozumět kódu nakonec v bloku bloku se provede po návratu příkaz .

public class TestTryCatchFinally {
    static int x = 0;

    public static void main(String[] args){
        System.out.println(f1() );
        System.out.println(f2() );
    }

    public static int f1(){
        try{
            x = 1;
            return x;
        }finally{
            x = 2;
        }
    }

    public static int f2(){
        return x;
    }
}
4
eric2323223

Byl jsem velmi zmatený se všemi odpověďmi poskytnutými na různých fórech a rozhodl se konečně kód a vidět. Výstup je:

nakonec bude provedeno, i když je návrat v pokusu a blokování.

try {  
  System.out.println("try"); 
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} catch (Exception e) {   
  System.out.println("catch");
  return;
  //int  i =5/0;
  //System.exit(0 ) ;
} finally {  
   System.out.println("Print me FINALLY");
}

Výstup

snaž se

Vytiskněte mě konečně

  1. Je-li vrácení nahrazeno znakem System.exit(0) v bloku try a catch ve výše uvedeném kódu a dojde k výjimce před ním, z jakéhokoli důvodu.
4
milton

konečně lze také předčasně ukončit, pokud je uvnitř vnořeného bloku vhozena výjimka. Kompilátor vás upozorní, že poslední blok se nedokončí normálně nebo nedojde k chybě, kterou máte nedosažitelný kód. Chyba pro nedostupný kód bude zobrazena pouze v případě, že hod není za podmíněným příkazem nebo uvnitř smyčky.

try{
}finally{
   try{
   }finally{
      //if(someCondition) --> no error because of unreachable code
      throw new RunTimeException();
   }
   int a = 5;//unreachable code
}
3
HopefullyHelpful

Nakonec je vždy zavolán na konci

když se pokusíte, provede nějaký kód, pokud se něco stane v pokusu, pak úlovek zachytí tuto výjimku a vy můžete vytisknout nějaké mssg ven nebo hodit chybu, pak nakonec se provede blok.

Konečně se obvykle používá při čištění, například pokud používáte skener v Javě, měli byste pravděpodobně skener zavřít, protože to vede k dalším problémům, například k tomu, že není možné otevřít nějaký soubor.

2
Rubin Luitel

nakonec se blok provádí vždy, i když v bloku pokusu vložíte příkaz return. Konečný blok bude proveden před příkazem return.

2
Sabrina