Assegnazione di un valore predefinito a una variabile finale in caso di un'eccezione in Java

Question

Perché Java non mi consente di assegnare un valore a una variabile finale in un blocco catch dopo aver impostato il valore nel blocco try, anche se non lo è possibile per il valore finale da scrivere in caso di eccezione.

Ecco un esempio che illustra il problema:

public class FooBar { 

    private final int foo; 

    private FooBar() { 
     try { 
      int x = bla(); 
      foo = x; // In case of an exception this line is never reached 
     } catch (Exception ex) { 
      foo = 0; // But the compiler complains 
        // that foo might have been initialized 
     } 
    } 

    private int bla() { // You can use any of the lines below, neither works 
     // throw new RuntimeException(); 
     return 0; 
    } 
} 

Il problema non è difficile da risolvere, ma vorrei capire perché il compilatore non accetta questo.

Grazie in anticipo per eventuali ingressi!

Answer 1

try { 
    int x = bla(); 
    foo = x; // In case of an exception this line is never reached 
} catch (Exception ex) { 
    foo = 0; // But the compiler complains 
      // that foo might have been initialized 
} 

Il motivo è perché il compilatore non può dedurre che l'eccezione può essere lanciata solo prima foo è initalized. Questo esempio è un caso particolare in cui è evidente che questo è vero, ma prendere in considerazione:

try { 
    int x = bla(); 
    foo = x; // In case of an exception this line is never reached...or is it? 
    callAnotherFunctionThatThrowsAnException(); // Now what? 
} catch (Exception ex) { 
    foo = 0; // But the compiler complains 
      // that foo might have been initialized, 
      // and now it is correct. 
} 

Per scrivere un compilatore per gestire casi molto specifici come questo sarebbe un compito immenso - ci sono probabilmente molti di loro.

Answer 2

Che ne dici di un lancio Error?

Answer 3

Per essere un pedante, Thread.stop(Throwable) potrebbe generare un'eccezione immediatamente dopo l'assegnazione del blocco try.

Tuttavia, le regole con assegnazione definita e termini affini sono abbastanza complesse. Controlla il JLS. Cercare di aggiungere più regole complicherebbe la lingua e non fornirà un vantaggio significativo.