Asignación de un valor predeterminado a una variable final en caso de una excepción en Java

Question

¿Por qué Java no me deja asignar un valor a una variable final en un bloque catch después de establecer el valor en el bloque try, incluso si no es posible para que se escriba el valor final en caso de una excepción.

Aquí es un ejemplo que muestra el 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; 
    } 
} 

El problema no es difícil de evitar, pero me gustaría entender por qué el compilador no acepta esto.

¡Gracias de antemano por cualquier entrada!

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 
} 

La razón es porque el compilador no puede deducir que la excepción sólo puede ser lanzado antes de foo se initalized. Este ejemplo es un caso especial de que es obvio que eso es cierto, pero hay que considerar:

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. 
} 

Para escribir un compilador para manejar casos muy específicos como esta sería una tarea inmensa - hay probablemente muchos de ellos.

Answer 2

¿Qué tal una lanzada Error?

Answer 3

Para ser un pedante, Thread.stop(Throwable) podría arrojar una excepción inmediatamente después de la asignación del bloque try.

Sin embargo, las reglas con asignación definida y términos afines son lo suficientemente complejas. Compruebe el JLS. Tratar de agregar más reglas complicaría el lenguaje y no proporcionaría un beneficio significativo.