La clave finalmente en Java se usa generalmente con TRY. Ejemplo para ilustrar:
La clase pública TryandFinallyTest {public static void main (String [] args) lanza la excepción {try {int a = testFinally (2); ) {int b = testFinally (1); B) B = TestFinally (4); :::::::::::::::::::::::::::::::::::::::::::::::::::::: :::::::::::::::::::::::::::::::::::::::::::::::::::::: ::::::::::::::::::::::::::::::: Prueba el alcance si el programa lanza una excepción u otra interrupción, el contenido de finalmente se ejecutará Switch (i) {Caso 1: ++ i; break; // El programa termina normalmente 2: tirar una nueva excepción ("Excepción bajo la prueba"); ("Finalmente viene cuando i ="+Flag);Los resultados de la ejecución son los siguientes
Finalmente, cuando llegó a I = 2finalmente cuando viene cuando i = 1 el resultado regresó normalmente b: 2finalmente que viene cuando i = 3break devuelve el resultado: 3finalmente que viene cuando i = 4Return devuelve el resultado: -1
El resultado muestra que no importa cuál sea la situación anterior, el bloque finalmente siempre se ejecutará.
En comparación con otros modelos de idiomas, la palabra clave finalmente es la mejor adición al modelo de manejo de excepciones Java. La estructura finalmente permite que el código siempre se ejecute independientemente de si se produce la excepción. Use finalmente para mantener el estado interno de un objeto y para limpiar los recursos no memoria. Sin finalmente, su código será confuso. Por ejemplo, el siguiente código ilustra cómo tiene que escribir código para liberar recursos no memoria sin usar finalmente:
import java.net.*; .accept ();
Este código crea un socket y llama al método de aceptación. Antes de salir del método, debe cerrar este enchufe para evitar vulnerabilidades de recursos. Para lograr esta tarea, llamamos a Close AT // 2, que es la última declaración del método. Pero, ¿qué sucede si se produce una excepción en el bloque de try? En este caso, la llamada cercana a // 2 nunca sucede. Por lo tanto, debe atrapar esta excepción e insertar otra llamada para cerrar AT // 1 antes de volver a emitir esta excepción. Esto asegura que el socket esté cerrado antes de salir del método.
Escribir código como este es a la vez engorrosa y propensa a errores, pero es esencial sin finalmente. Desafortunadamente, en los idiomas sin un mecanismo finalmente, los programadores pueden olvidarse de organizar su código de esta manera, lo que resulta en vulnerabilidades de recursos. La cláusula finalmente en Java resuelve este problema. Con finalmente, el código anterior se puede reescribir en el siguiente formulario:
import java.net.*; .accept ();
El bloque Finalmente asegura que el método de cierre siempre se ejecute independientemente de si se emite una excepción dentro del bloque Try. Por lo tanto, se asegura que el método de cierre siempre se llame antes de salir del método. De esta manera, puede estar seguro de que el socket está cerrado y que no ha filtrado recursos. No hay necesidad de otro bloque de captura en este método. El bloque de captura se proporciona en el primer ejemplo solo para cerrar el enchufe, ahora esto está cerrado finalmente. Si proporciona un bloque de captura, el código en el bloque finalmente se ejecuta después de que se termina el bloque de captura.
El bloque Finalmente se debe usar con el bloque de try o try/captación. Además, no es posible salir del bloque de try sin ejecutar su bloque finalmente. Si el bloque Finalmente existe, siempre se ejecutará. (Esta declaración es correcta desde ese punto de vista. Hay una manera de salir del bloque de try sin ejecutar el bloque finalmente. Si el código ejecuta un sistema.exit (0); Declaración dentro de la prueba, la aplicación termina sin ejecutar finalmente ejecución . Por otro lado, si apagas el poder durante la ejecución del bloque de try, finalmente no lo hará.