¿Cuál es el punto del último bloque?

Bueno, por un lado, si VUELVES dentro de tu bloque try, el finally seguirá ejecutándose, pero el código que aparece debajo del bloque try-catch-finally no lo hará.

En Java:

Finalmente siempre se llama, independientemente de si la excepción fue capturada correctamente en catch(), o de hecho si tiene un catch en absoluto.

Try catch finalmente es una construcción bastante importante. Puede estar seguro de que incluso si se lanza una excepción, el código en finally block se ejecutará. Es muy importante en el manejo de recursos externos para liberarlos. La recolección de basura no hará eso por ti. En finally part no deberías tener declaraciones return o excepciones throw. Es posible hacer eso, pero es una mala práctica y puede conducir a resultados impredecibles.

Si intentas esto ejemplo:

try {
  return 0;
} finally {
  return 2;
}

El resultado será 2:)

Comparación con otros idiomas: Volver De Finally

Hay varias cosas que hacen útil un bloque finally:

1. Si regresa de los bloques try o catch, el bloque finally se sigue ejecutando, justo antes de que se devuelva el control a la función que llama
2. Si se produce una excepción dentro del bloque catch, o se produce un tipo de excepción no capturada en el bloque try, el código en el bloque finally se sigue ejecutando.

Estos hacen que finalmente los bloques sean excelentes para cerrar manijas de archivos o sockets.

En el caso de que el try y el catch estén vacíos, no hay diferencia. De lo contrario, puede estar seguro de que finalmente se ejecutará.

Si, por ejemplo, lanza una nueva Excepción en su bloque de captura (rethrow), la asignación solo se ejecutará si está en el bloque finally.

Normalmente se usa finalmente para limpiar después de ti mismo (cerrar conexiones DB, Manejadores de archivos y similares).

Nunca debe usar instrucciones de control (return, break, continue) en a finalmente, ya que esto puede ser una pesadilla de mantenimiento y por lo tanto se considera una mala práctica

El bloque final siempre será llamado (bueno, no realmente siempre... ) incluso si se lanza una excepción o se alcanza una sentencia return (aunque eso puede depender del idioma). Es una forma de limpiar que sabes que siempre se llamará.

@iAn y @ mats:

No "derribaría" nada en finally {} que estuviera "configurado" dentro del try {} como regla. Sería mejor tirar de la creación de flujo fuera del try {}. Si necesita manejar una excepción en stream create, esto podría hacerse en un ámbito mayor.

StreamReader stream = new StreamReader("foo.bar");  
try {
    mySendSomethingToStream(stream);
}
catch(noSomethingToSendException e) {
    //Swallow this    
    logger.error(e.getMessage());
}
catch(anotherTypeOfException e) {
    //More serious, throw this one back
    throw(e);
}
finally {
    stream.close();  
}

Para que pueda limpiar cualquier conexión abierta, etc. inicializado en el bloque try. Si abrió una conexión y luego se produjo una excepción, esa excepción no se cerraría correctamente. Este tipo de escenario es para lo que está el bloque finally.

Se supone que el bloque finally se ejecuta, ya sea que haya capturado la excepción o no. Ver Try / Catch / Finally ejemplo

@Ed , usted podría estar pensando en algo como un catch(...) que captura una excepción no especificada en C++.

Pero finally es el código que se ejecutará sin importar lo que suceda en los bloques catch.

Microsoft tiene una página de ayuda en try-finally para C #

El bloque finally está en el mismo ámbito que el try/catch, por lo que tendrá acceso a todas las variables definidas dentro.

Imagine que tiene un manejador de archivos, esta es la diferencia en cómo se escribiría.

try
{
   StreamReader stream = new StreamReader("foo.bar");
   stream.write("foo");
}
catch(Exception e) { } // ignore for now
finally
{
   stream.close();
}

Comparado con

StreamReader stream = null;
try
{
    stream = new StreamReader("foo.bar");
    stream.write("foo");
} catch(Exception e) {} // ignore

if (stream != null)
    stream.close();

Recuerde sin embargo que cualquier cosa dentro finalmente no está garantizada para funcionar. Imagine que recibe una señal de aborto, Windows se bloquea o la energía se ha ido. Confiar en finalmente para el código crítico de negocio es malo.

Cualquier código en el finally se ejecuta en el even en el caso de una excepción no controlada. Por lo general, el código finally se utiliza para limpiar declaraciones locales de código no administrado utilizando .disponer().

Finalmente, los bloques le permiten, como desarrollador, ordenar después de sí mismo, independientemente de las acciones de código que preceden en el bloque try{} errores encontrados, y otros han señalado esto, se cae principalmente bajo el paraguas de liberar recursos - cerrando punteros / sockets / conjuntos de resultados, devolviendo conexiones a un grupo, etc.

@mats es muy correcto que siempre existe el potencial de fallas "duras": finalmente, los bloques no deberían incluir código de misión crítica, que debería siempre se debe hacer transaccionalmente dentro del try {}

@mats de nuevo - La verdadera belleza es que le permite tirar excepciones de sus propios métodos, y aún así garantizar que usted ordena:

try
{
StreamReader stream = new StreamReader("foo.bar");
mySendSomethingToStream(stream);
}
catch(noSomethingToSendException e) {
    //Swallow this    
    logger.error(e.getMessage());
}
catch(anotherTypeOfException e) {
    //More serious, throw this one back
    throw(e);
}
finally
{
stream.close();
}

Por lo tanto, podemos capturar muchos tipos de excepción, procesarlos de manera diferente (el primero permite la ejecución de cualquier cosa más allá del try{}, el segundo efectivamente devuelve), pero siempre limpia y ordenadamente.

En Java, lo usa para cualquier cosa que desee ejecutar independientemente de si usó un "return", simplemente corrió a través del bloque try, o tuvo una excepción atrapada.

Por ejemplo, cerrar una sesión de base de datos o una conexión JMS, o desasignar algún recurso del sistema operativo.

Supongo que es similar en. NET?