Los ejemplos de este artículo describen el uso del manejo de excepciones de Java. Compártelo con todos para tu referencia. El análisis específico es el siguiente:
El mecanismo de manejo de excepciones de Java puede ayudarnos a evitar o manejar errores que pueden ocurrir en el programa, de modo que el programa no finalice inesperadamente cuando encuentre algunos errores recuperables, pero a manejar estos errores, lo que también nos hace mejores escribiendo programas. Es necesario escribir mucho código para comprobar las condiciones de error, lo que mejora la legibilidad y la lógica del código. En Java, una excepción representa un objeto de entidad incorrecto.
Las excepciones se pueden dividir en dos categorías: una son errores graves, como errores de hardware, memoria insuficiente, etc., que corresponden a la clase Error y sus subclases en el paquete java.lang. Por lo general, este tipo de programa de error en sí no se puede recuperar y necesita interrumpir la ejecución del programa. El otro tipo son errores no graves, como que el usuario ingrese datos ilegales, divida por 0, etc. Corresponden a la clase de excepción y Sus excepciones en la subclase del paquete java.lang, este tipo de error generalmente se pueden recuperar sin afectar el funcionamiento del programa.
Podemos usar palabras clave try, catch y finalmente para detectar excepciones.
1. intentar, atrapar
Coloque las declaraciones que pueden causar excepciones en el bloque try{} y luego captúrelas en el bloque de declaraciones catch{}. Excepción si se divide por 0:
public class SimpleDemo { // Operación de división public static int devision(int a,int b) { return a / b } public static void main(String[] args) { try { //5 dividido por 0 SimpleDemo.devision(5 ,0); System.out.println("Excepción"); captura (Excepción e) { e.printStackTrace() } System.out.println("Finalizar");Resultado de la ejecución:
Como puede ver, se imprime Finalizar, lo que indica que el programa no finalizó debido a un error de división por 0.
Al mismo tiempo, también descubrimos que la instrucción System.out.println en SimpleDemo.devision() donde ocurrió la excepción no se ejecutó. Una vez que ocurre una excepción, el programa saltará de la posición de ejecución actual sin ejecutar las declaraciones posteriores a la excepción.
2. finalmente
Las declaraciones en el bloque finalmente se ejecutarán independientemente de si ocurre una excepción.
Alguien puede preguntar, dado que las declaraciones en el bloque finalmente se ejecutarán independientemente de si ocurre una excepción, ¿cuál es el efecto práctico de esto finalmente? ¿No puedo escribirlo directamente afuera sin finalmente?
Como en el ejemplo anterior, agregamos un retorno al bloque de declaración catch:
public class SimpleDemo { // Operación de división public static int division(int a,int b) { return a / b } public static void main(String[] args) { try { //5 dividido por 0 SimpleDemo.division(5 ,0); System.out.println("Excepción"); captura (Excepción e) { e.printStackTrace(); //la función principal regresa} finalmente { System.out.println("Finalmente"); } System.out.println("Finalizar");En este momento, el Finalizar fuera del bloque finalmente no se imprime, pero el Finalmente dentro del bloque finalmente sí se imprime.
Finalmente es muy útil en el desarrollo real. Por ejemplo, si abrimos una base de datos y ocurre una excepción al leer y escribir datos en la base de datos, entonces debemos cerrar la conexión de la base de datos y liberar los recursos correspondientes. En este momento, lo más apropiado es escribir código para liberar recursos en el bloque finalmente.
Pero cabe señalar que el bloque finalmente no se ejecutará en un caso. Si el programa sale antes de ejecutar el bloque finalmente, como llamar al método System.exit(), el bloque finalmente no tendrá la oportunidad de ejecutarse.
3. Lanzar una excepción
Si ocurre una excepción en un método, pero no queremos manejar la excepción directamente en el método, pero queremos que la persona que llama al método la maneje, podemos usar la palabra clave throws para declarar que este método arroja la excepción. Esto es muy común en las funciones API proporcionadas por Sun. Por ejemplo, se declara que el método de lectura en java.io.Reader arroja una IOException:
public int read(char[] cbuf) lanza IOException
En este momento, cuando llamamos al método de lectura, debemos colocarlo en el bloque de declaración de prueba para detectar excepciones; de lo contrario, el compilador informará un error y nos obligará a detectar excepciones.
Por supuesto, si realmente no queremos manejar excepciones al llamar a read, también podemos declarar el método que llama al método de lectura como throws IOException, de modo que la excepción se vuelva a lanzar. Si declaramos una excepción en la función principal, la información de la excepción eventualmente será capturada y procesada por la JVM, y el resultado del procesamiento de la JVM es imprimir la información de la excepción y luego finalizar el programa.
4. Estructura de manejo de excepciones
Todas las clases de excepción se derivan de la clase Exception. Esto significa que si no estamos seguros de qué tipo de excepción ocurrirá, podemos declarar directamente un objeto Exception en catch para capturar todas las excepciones de la clase Exception y sus subclases. Pero preste atención al orden en que se escribe catch. Si hay varias capturas después de un intento y la primera captura declara un objeto de excepción, la excepción será manejada directamente por la primera captura y las capturas posteriores no podrán detectar esta excepción. Este tipo de error generará un error durante la compilación. Por ejemplo:
clase pública CatchDemo { // Operación de división public static int division(int a,int b) { return a / b } public static void main(String[] args) { try { CatchDemo.division(4,0 } catch); (Excepción e) { System.out.println("Clase de excepción"); catch(ArithmeticException e) { System.out.println("Clase de excepción Arithmetic"); } } }El compilador genera que se ha detectado ArithmeticException, lo que significa que la excepción anterior ha detectado esta excepción y no es necesario detectarla nuevamente.
¿Qué pasaría si se invirtieran estas dos capturas?
clase pública CatchDemo { // Operación de división public static int division(int a,int b) { return a / b } public static void main(String[] args) { try { CatchDemo.division(4,0 } catch); (ArithmeticException e) { System.out.println("Clase ArithmeticException" } catch(Exception e) { System.out.println("Clase de excepción"); } } }En este momento descubrimos que el código pasó la compilación y el resultado de la ejecución fue que ArithmeticException detectó esta excepción, pero la captura posterior no la detectó.
Espero que este artículo sea útil para la programación Java de todos.