1. Introducción
Intenta ... atrapar ... finalmente es probablemente una oración con la que todos están familiarizados, y se siente muy simple de usar, y parece lógicamente fácil de entender. Sin embargo, el "aprendizaje" que experimenté me dijo personalmente que esto no es tan simple y obediente como imaginaba. ¿No lo crees? Luego, mire el código a continuación, ¿cuál será el resultado después de que se ejecute? No mire las respuestas al revés, ni permite que se ejecute el código para ver las respuestas reales. Si su respuesta es correcta, entonces no tiene que perder el tiempo leyendo este artículo.
prueba de paquete; public class testException {public testException () {} boolean testEx () lanza la excepción {boolean ret = true; intente {ret = testEx1 (); } catch (Exception e) {System.out.println ("testEx, Catch Exception"); Ret = falso; tirar E; } Finalmente {System.out.println ("testEx, finalmente; return value =" + ret); regresar ret; }} boolean testEx1 () lanza la excepción {boolean ret = true; intente {ret = testEx2 (); if (! ret) {return false; } System.out.println ("testEx1, al final de la prueba"); regresar ret; } catch (Exception e) {System.out.println ("testEx1, Catch Exception"); Ret = falso; tirar E; } Finalmente {System.out.println ("testEx1, finalmente; return value =" + ret); regresar ret; }} boolean testEx2 () lanza la excepción {boolean ret = true; intente {int b = 12; int c; para (int i = 2; i> = -2; i--) {c = b / i; System.out.println ("i =" + i); } return verdadero; } catch (Exception e) {System.out.println ("testEx2, Catch Exception"); Ret = falso; tirar E; } Finalmente {System.out.println ("testEx2, finalmente; return value =" + ret); regresar ret; }} public static void main (string [] args) {testException testException1 = new testException (); intente {testException1.testex (); } catch (Exception e) {E.PrintStackTrace (); }}} ¿Cuál es tu respuesta? ¿Es la respuesta a continuación?
i = 2
i = 1
testEx2, excepción de captura
testEx2, finalmente; Valor de retorno = falso
testEX1, excepción de captura
testEx1, finalmente; Valor de retorno = falso
testEX, excepción de captura
testEx, finalmente; Valor de retorno = falso
Si su respuesta es realmente como se mencionó anteriormente, entonces está equivocado. ^_^, luego le sugiero que lea este artículo cuidadosamente o use el código anterior para modificar, ejecutar y probar de acuerdo con varias situaciones. Encontrará que hay muchas cosas que no son tan simples como se imagina originalmente. Ahora publique la respuesta correcta:
i = 2
i = 1
testEx2, excepción de captura
testEx2, finalmente; Valor de retorno = falso
testEx1, finalmente; Valor de retorno = falso
testEx, finalmente; Valor de retorno = falso
Nota:
Finalmente, el bloque de la declaración no debería aparecer, debería aparecer el retorno. El retorno RET anterior es preferiblemente otra declaración para manejar la lógica relevante.
2. Excepción de Java
Las excepciones se refieren a diversas situaciones que ocurren inesperadamente, como: Archivo no encontrado, falla de conexión de red, parámetros ilegales, etc. Una excepción es un evento que ocurre durante la ejecución del programa e interfiere con el flujo de instrucción normal. Java describe varias excepciones a través de muchas subclases de la clase lanzable en la API. Por lo tanto, las excepciones de Java son objetos, instancias de subclases tiradas, que describen las condiciones de error que aparecen en una codificación. Cuando se genera una condición, un error arrojará una excepción.
Diagrama de jerarquía de clase de excepción de Java:
Figura 1 Diagrama de jerarquía de clase de excepción de Java
En Java, todas las excepciones tienen un antepasado común, lanzable (lanzable). Lanzable especifica la comunidad de cualquier problema que pueda transmitirse a través de aplicaciones Java en el código mediante mecanismos de propagación de excepciones.
Tirable: hay dos subclases importantes: excepción y error. Ambas son subclases importantes para el manejo de excepciones Java, y cada una contiene una gran cantidad de subclases.
Error: un error que el programa no puede manejar, lo que indica un problema grave en la ejecución de la aplicación. La mayoría de los errores no están relacionados con las acciones realizadas por el escritor de código, sino que representan problemas con la JVM (Java Virtual Machine) cuando se ejecuta el código. Por ejemplo, una máquina virtual Java ejecuta un error (virtual MachineError), y un OutOfMemoryError aparecerá cuando el JVM ya no tenga los recursos de memoria necesarios para continuar la operación. Cuando se producen estas excepciones, la máquina virtual Java (JVM) generalmente elige terminar los subprocesos.
Estos errores indican que la falla ocurre cuando la máquina virtual en sí, o cuando la máquina virtual intenta ejecutar la aplicación, como una máquina virtual Java que ejecuta un error (virtual máquina de máquina), error de definición de clase (noclassdeffounderror), etc. Estos errores no se pueden detectar porque están fuera del control y las capacidades de procesamiento de la aplicación, y la mayoría de las situaciones que no están permitidas cuando se les permite ocurrir el programa. Para una aplicación bien diseñada, incluso si se produce un error, no debe intentar esencialmente lidiar con las excepciones que causa. En Java, el error se describe mediante una subclase de error.
Excepción: una excepción que el programa en sí puede manejar.
La clase de excepción tiene una subclase importante, RuntimeException. La clase RuntimeException y sus subclases representan un error planteado por las "operaciones JVM comunes". Por ejemplo, si intenta usar una referencia de objeto nulo, cero divisor o matriz fuera de los límites, una excepción de tiempo de ejecución (NullPointerException, ArithmeticException) y ArrayIndexOutofBoundException se elevan respectivamente.
Nota: La diferencia entre excepciones y errores: las excepciones pueden ser manejadas por el programa en sí, pero los errores no pueden manejarse.
En general, las excepciones de Java (incluida la excepción y el error) se dividen en excepciones verificadas y excepciones sin control.
Se pueden verificar excepciones (excepciones que deben ser manejadas por el compilador): es fácil de ocurrir y excepciones razonables y tolerantes cuando el programa correcto se está ejecutando. Aunque la excepción de control es una condición anormal, su ocurrencia es predecible hasta cierto punto, y una vez que ocurre una condición tan anormal, debe manejarse de alguna manera.
A excepción de RuntimeException y sus subclases, otras clases de excepción y sus subclases son todas las excepciones a verificación. La característica de esta excepción es que el compilador Java lo verificará, es decir, cuando tal excepción puede ocurrir en el programa, lo atrapará con la declaración de prueba de prueba o lo lanzará con la cláusula de lanzamiento, de lo contrario, la compilación no pasará.
Excepciones inquietables (excepciones de que el compilador no requiere eliminación forzada): incluidas las excepciones de tiempo de ejecución (runtimeException y sus subclases) y errores (error).
Excepción Esta excepción se divide en dos categorías: excepción de tiempo de ejecución y excepción no de runtime (excepción de compilación). Estas excepciones deben manejarse tanto como sea posible en el programa.
Excepciones de tiempo de ejecución: todas son la clase RuntimeException y sus excepciones de subclase, como NullPointerException (excepción del puntero nulo), indexOtoutOfBoundSexCeption (la excepción de subíndice fuera de los límites), etc. Estas excepciones no verifican las excepciones, y puede elegir capturar y procesarlos en el programa, o no puede manejarlos. Estas excepciones generalmente son causadas por errores lógicos del programa, y los programas deben evitar tales excepciones tanto como sea posible desde una perspectiva lógica.
La característica de la excepción de tiempo de ejecución es que el compilador Java no lo verificará. Es decir, cuando tal excepción puede ocurrir en el programa, incluso si no se captura con la declaración Try-Catch y se lanza con la cláusula de lanzamiento, se compilará y pasará.
Excepción de no runtime (excepción de compilación): es una excepción que no sea RuntimeException, y pertenece a la clase de excepción y sus subclases en términos de tipo. Desde la perspectiva de la sintaxis del programa, es una excepción que debe procesarse. Si no se procesa, el programa no puede ser compilado y aprobado. Tales como IOException, SQLException, etc., y excepciones de excepción definidas por el usuario, en general, no se verifican excepciones de verificación personalizadas.
3. Mecanismo de manejo de excepciones
En las aplicaciones Java, el mecanismo de manejo de excepciones es: arrojar excepciones y excepciones de captura.
Lanza una excepción: cuando ocurre un error en un método y plantea una excepción, el método crea un objeto de excepción y lo entrega al sistema de tiempo de ejecución. El objeto de excepción contiene información de excepción como el tipo de excepción y el estado del programa cuando se produce la excepción. El sistema de tiempo de ejecución es responsable de encontrar y ejecutar código para manejar excepciones.
Excepción de captura: después de que el método lanza una excepción, el sistema de tiempo de ejecución se convertirá en buscar un controlador de excepción adecuado. Un potencial manejador de excepciones es una colección de métodos que quedan en la pila de llamadas a su vez cuando se produce una excepción. Cuando el tipo de excepción que puede manejar el procesador de excepciones es consistente con el tipo de excepción lanzado por el método, es un procesador de excepción adecuado. El sistema de tiempo de ejecución comienza con el método donde se produce una excepción, y luego mira hacia atrás en los métodos de la pila de llamadas a su vez hasta que encuentre un método que contenga un controlador de excepción adecuado y lo ejecute. Cuando el sistema de tiempo de ejecución atraviesa la pila de llamadas y no encuentra un controlador de excepción adecuado, el sistema de tiempo de ejecución termina. Al mismo tiempo, significa la terminación del programa Java.
Para las excepciones de tiempo de ejecución, errores o excepciones detectables, los métodos de manejo de excepciones requeridos por la tecnología Java son diferentes.
Debido a las excepciones de tiempo de ejecución indetectables, para implementar la aplicación de manera más razonable y fácil, Java estipula que las excepciones de tiempo de ejecución serán lanzadas automáticamente por el sistema de tiempo de ejecución Java, lo que permite que la aplicación ignore las excepciones de tiempo de ejecución.
Para los errores que pueden ocurrir durante la operación del método, Java permite que el método no arroje ninguna declaración cuando el método no debe ser capturado. Debido a que la mayoría de las excepciones de error son situaciones que nunca se pueden permitir que ocurra, y también son excepciones que las aplicaciones razonables no deberían atrapar.
Para todas las excepciones a verificación, Java estipula que un método debe ser atrapado o declarado fuera del método de lanzamiento. Es decir, cuando un método elige no atrapar una excepción de control, debe declarar que se lanzará la excepción.
Un método que puede capturar excepciones requiere proporcionar un tipo de controlador de excepción correspondiente. La excepción atrapada puede ser causada por una excepción planteada y lanzada por su propia declaración, o una excepción lanzada por un método llamado o sistema de tiempo de ejecución Java, etc. En otras palabras, la excepción que un método puede atrapar debe ser una excepción lanzada por el código Java en alguna parte. En pocas palabras, las excepciones siempre se lanzan primero y luego se atrapan.
Cualquier código Java puede lanzar excepciones, como: código escrito por usted mismo, código del paquete de entorno de desarrollo Java o el sistema de tiempo de ejecución Java. No importa quién sea, puedes lanzar una excepción a través de la declaración de lanzamiento de Java.
Cualquier excepción lanzada desde el método debe usarse con la cláusula de lanzamiento.
Las excepciones de captura se logran a través de declaraciones de prueba de prueba o declaraciones de prueba de captura de prueba finalmente.
En términos generales, Java estipula que las excepciones a verificación deben ser atrapadas o declaradas arrojadas. Permite ignorar RuntimeException y error sin control.
3.1 Excepciones de captura: intente, atrapar y finalmente
1. Declaración de captura de tráfico
En Java, las excepciones se ven capturadas por una declaración de prueba de prueba. Su forma de sintaxis general es:
Pruebe {// Código de programa donde pueden ocurrir excepciones} Catch (Type1 ID1) {// Catch y tratar con el tipo de excepción lanzado por Try Type1} Catch (Type2 ID2) {// Catch y tratar con el tipo de excepción lanzado por Try Type2}Un par de aparatos ortopédicos después de la palabra clave intenta envolver un código que puede tener una excepción, que se llama área de monitoreo. Si se produce una excepción durante el método Java durante la ejecución, se crea un objeto de excepción. Lanza la excepción fuera del área de monitoreo, y el sistema de ejecución de Java intenta encontrar una cláusula de captura coincidente para detectar la excepción. Si hay una cláusula de captura coincidente, ejecute su código de manejo de excepciones y finaliza la instrucción Try-Catch.
El principio de coincidencia es: si el objeto de excepción lanzado pertenece a la clase de excepción de la cláusula de captura o pertenece a una subclase de la clase de excepción, se considera que el objeto de excepción generado coincide con el tipo de excepción capturado por el bloque de captura.
Ejemplo 1 Atrapa la excepción de "divididor es 0" lanzada por la declaración de lanzamiento.
public class testException {public static void main (string [] args) {int a = 6; int b = 0; intente {// intente el área de monitoreo si (b == 0) tire nuevo arithmeticException (); // Lanzar excepción a través de la declaración de lanzamiento System.out.println ("El valor de A/ B es:" + A/ B); } Catch (arithmeticException e) {// captura de capturas Exception System.out.println ("El programa tiene una excepción y la variable B no puede ser 0."); } System.out.println ("El programa termina normalmente"); }}Resultado en ejecución: el programa tiene una excepción y la variable B no puede ser 0.
El programa termina normalmente.
Ejemplo 1 En el área de monitoreo de intentos, use la declaración IF para juzgar. Cuando se establece la condición de error de "divisor es 0", se crea una excepción de ArithMeticException y la declaración de lanzamiento lanza la excepción al sistema de tiempo de ejecución Java. El sistema encuentra un controlador de excepción coincidente y ejecuta el código de manejo de excepciones correspondiente. Imprimir "El programa tiene una excepción, y la variable B no puede ser 0" La instrucción Try-Catch termina y continúa el flujo del programa.
De hecho, arithmeticexception como "divisor es 0" es una subclase de Runtimexception. La excepción de tiempo de ejecución será lanzada automáticamente por el sistema de tiempo de ejecución, y no hay necesidad de usar una declaración de lanzamiento.
Ejemplo 2: Atrapa la excepción de ArithmeticeException causada por el "divisor es 0" que se lanza automáticamente durante el sistema de tiempo de ejecución.
public static void main (string [] args) {int a = 6; int b = 0; Pruebe {System.out.println ("El valor de A / B es:" + A / B); } Catch (arithmeticException e) {system.out.println ("El programa tiene una excepción, y la variable B no puede ser 0."); } System.out.println ("El programa termina normalmente"); }}Resultado en ejecución: el programa tiene una excepción y la variable B no puede ser 0.
El programa termina normalmente.
Declaración en el ejemplo 2:
System.out.println ("El valor de A/B es:" + A/B);Se generó un error de "divisor es 0" durante el tiempo de ejecución, y se planteó una excepción de ArithmeticException. El sistema de tiempo de ejecución crea un objeto de excepción y lanza un área de monitoreo, en su lugar coincide con la captura de controlador de excepción apropiada y ejecuta el código de manejo de excepciones correspondiente.
Dado que el costo de verificar las excepciones de tiempo de ejecución es mucho mayor que los beneficios de la captura de excepciones, no se pueden detectar excepciones de tiempo de ejecución. El compilador de Java permite ignorar las excepciones de tiempo de ejecución, y un método no puede atrapar ni declarar arrojar excepciones de tiempo de ejecución.
Ejemplo 3: Sin capturar ni declarar que se lanza la excepción de tiempo de ejecución.
public class testException {public static void main (string [] args) {int a, b; a = 6; b = 0; // El valor del divisor B es 0 System.out.println (A / B); }}Resultados de ejecución:
Excepción en el hilo "principal" java.lang.arithmeticexception: / por cero
en test.testexception.main (testException.java:8)
Ejemplo 4 El programa puede tener una excepción de Divisor 0 y una excepción de la subíndice de matriz fuera de los límites.
public class testException {public static void main (string [] args) {int [] intarray = new int [3]; Pruebe {for (int i = 0; i <= intarray.length; i ++) {intarray [i] = i; System.out.println ("Intarray [" + i + "] =" + Intarray [i]); System.out.println ("Intarray [" + i + "] módulo" + (i - 2) + "Valores:" + Intarray [i] % (i - 2)); }} Catch (ArrayInDexuToFboundSexception e) {System.out.println ("Excepción de subíndice de la matriz Intarray fuera de los límites"); } catch (arithmeticException e) {system.out.println ("excepción del divisor 0."); } System.out.println ("El programa termina normalmente"); }}Resultados de ejecución:
Intarray [0] = 0
Intarray [0] Valor del módulo-2: 0
Intarray [1] = 1
El valor de Intarray [1] Modulo-1: 0
Intarray [2] = 2
Excepción del divisor 0.
El programa termina normalmente.
Ejemplo 5 El programa puede experimentar una excepción del divisor 0, y también puede ocurrir una excepción de los subíndices de matriz. Durante la ejecución del programa, primero las coinciden con el tipo de excepción ARITHMETICEXCERTCE, por lo que se ejecuta la declaración de captura coincidente:
Catch (arithmeticException e) {System.out.println ("Excepción del divisor 0."); }Cabe señalar que una vez que una captura captura el tipo de excepción de correspondencia, ingresará el código de manejo de excepciones. Una vez que se termina el procesamiento, significa que finaliza toda la instrucción Try-Catch. Otras cláusulas de captura ya no tienen la oportunidad de igualar y atrapar tipos de excepción.
Java describe los tipos de excepción a través de clases de excepción, y la jerarquía de clases de excepción se muestra en la Figura 1. Para programas de excepción con múltiples cláusulas de captura, debe intentar poner la cláusula de captura que atrapa primero la clase de excepción subyacente, e intentar poner la cláusula de captura que atrapa la clase de excepción de nivel relativamente alto más tarde. De lo contrario, la cláusula de captura que atrapa la clase de excepción subyacente probablemente será bloqueada.
La clase RuntimeException Exception incluye varias excepciones comunes en tiempo de ejecución, y la clase ArithmeticException y la clase ArrayInDexOutofBoundSException son subclases. Por lo tanto, la cláusula de captura de la clase de excepción RuntimeException debe colocarse al final, de lo contrario puede bloquear el manejo de excepciones posteriores o causar un error de compilación.
2. Declaración de prueba-Catch-Finally
La declaración Try-Catch también puede incluir la tercera parte, que es la cláusula Finalmente. Indica lo que debe ejecutarse independientemente de si se produce una excepción o no. El formulario de sintaxis general de la instrucción Try-Catch-Finally es:
Pruebe {// código de programa que puede ocurrir excepción} capt (tipo1 id1) {// captura y procesa el tipo de excepción lanzado por try type1} capt (type2 id2) {// captura y procesa el tipo de excepción lanzado por try type2} finalmente {// bloque de declaraciones que se ejecutarán sin embargo si se produce una excepción}Ejemplo 6 Handler de excepciones con cláusula Finalmente.
public class testException {public static void main (string args []) {int i = 0; Saludos de cadena [] = {"¡Hola mundo!", "¡Hola mundo!", "¡Hola mundo!" }; mientras (i <4) {try {// presta especial atención al diseño de la variable de control de bucle i para evitar causar bucles infinitos system.out.println (saludos [i ++]); } Catch (ArrayInDexutefBoundSexception e) {System.out.println ("Excepción fuera de los límites de ArraySubScript"); } finalmente {System.out.println ("--------------------------"); }}}}Resultados de ejecución:
¡Hola Mundo!
--------------------------------
Hola Mundo !!
--------------------------------
¡¡¡HOLA MUNDO!!!
--------------------------------
Subíndice de matriz fuera de la excepción de los límites
--------------------------------
En el Ejemplo 6, preste especial atención al diseño del bloque de declaraciones en la cláusula de prueba. Si el diseño es el siguiente, se producirá un bucle muerto. Si está diseñado como:
intente {System.out.println (saludos [i]); i ++; }resumen:
Pruebe el bloque: se usa para atrapar excepciones. A partir de entonces, se pueden conectar cero o más bloques de captura. Si no hay bloque de captura, debe ser seguido por un bloque finalmente.
Bloque de captura: se usa para manejar las excepciones capturadas por Try.
Finalmente bloque: las declaraciones en el bloque finalmente se ejecutarán independientemente de si la excepción es atrapada o procesada. Cuando se encuentra una declaración de devolución en un bloque de try o bock de captura, el bloque de la declaración finalmente
Se ejecuta antes de que regrese el método. En los siguientes 4 casos especiales, el bloque finalmente no se ejecutará:
1) Se produjo una excepción en el bloque de instrucción Finalmente.
2) Use System.exit () en el código anterior para salir del programa.
3) El hilo donde se encuentra el programa muere.
4) Apague la CPU.
3. Regla de prueba-Catch-Finalmente (Regla gramatical para la declaración de manejo de excepciones):
1) Se debe agregar un bloque de captura o finalmente después del intento. Después del bloque TRY, la captura y finalmente los bloques se pueden conectar al mismo tiempo, pero hay al menos un bloque.
2) Se debe seguir el orden de bloque: si el código usa los bloqueos de captura y finalmente, el bloque de captura debe colocarse después del bloque de try.
3) El bloque de captura está relacionado con el tipo de clase de excepción correspondiente.
4) Un bloque de try puede tener múltiples bloques de captura. Si es así, se ejecuta el primer bloque coincidente. Es decir, la máquina virtual Java coincide con los objetos de excepción lanzados reales con los tipos de excepción declarados por cada bloque de código de captura en secuencia. Si el objeto de excepción es un tipo de excepción o una instancia de su subclase, se ejecutará el bloque de código de captura y no se ejecutará ningún otro bloque de código de captura.
5) Estructura anidada de prueba-Catch-Finalmente.
6) En la estructura de prueba de prueba finalmente, se puede rehacer una excepción.
7) Además de las siguientes situaciones, la ejecución de finalmente termina: el JVM termina prematuramente (llamado System.exit (int)); lanza una excepción no controlada en el bloque Finalmente; La computadora está apagada, despedida o atacada por un virus.
4. La orden de ejecución de los bloqueos de prueba, captura y finalmente de la declaración:
1) Cuando el intento no capta una excepción: las declaraciones en el bloque de la declaración de prueba se ejecutan una por una, y el programa omitirá el bloque de instrucciones de captura y ejecutará el bloque de instrucción finalmente y las declaraciones posteriores;
2) Cuando el intento atrapa una excepción, el bloque de instrucciones de captura no maneja esta excepción: cuando se produce una excepción en una declaración en el bloque de instrucciones de prueba y el bloque de instrucción de captura que no maneja esta excepción, la excepción se lanzará al JVM para su procesamiento, y la declaración en el bloque de la declaración finalmente aún se ejecutará, pero la declaración después del bloque de la declaración finalmente no se ejecutará;
3) Cuando un intento atrapa una excepción, el bloque de instrucciones de captura manejará esta excepción: se ejecuta en el bloque de instrucciones de prueba en orden. Cuando ocurre una excepción cuando ocurre una excepción en una determinada declaración, el programa saltará al bloque de la declaración de captura y lo coincidirá con uno por uno. Encuentra el controlador correspondiente. No se ejecutarán otros bloques de declaración de captura. En el bloque de la declaración de prueba, la declaración después de que ocurra una excepción no se ejecutará. Después de ejecutar el bloque de la declaración de captura, se ejecutará la declaración en el bloque de la declaración finalmente, y finalmente la declaración después de que se ejecutará el bloque de la declaración finalmente;
Ilustración de la ejecución de try, captura y finalmente bloqueos de instrucción:
La Figura 2 ilustra la ejecución de los bloqueos de prueba, captura y finalmente de la declaración
3.2 Lanza una excepción
Cualquier código Java puede lanzar excepciones, como: código escrito por usted mismo, código del paquete de entorno de desarrollo Java o el sistema de tiempo de ejecución Java. No importa quién sea, puedes lanzar una excepción a través de la declaración de lanzamiento de Java. Cualquier excepción lanzada desde el método debe usarse con la cláusula de lanzamiento.
1. Lanza una excepción de lanzamiento
Si un método puede tener una excepción pero no tiene la capacidad de manejar tal excepción, puede usar la cláusula de lanzamiento para declarar la excepción lanzada a la declaración del método. Por ejemplo, un automóvil puede fallar cuando se ejecuta, y el automóvil en sí no puede manejar esta falla, así que deje que el conductor se ocupe de él.
La declaración de lanzamiento se utiliza para declarar el tipo de excepción para lanzar cuando se define el método. Si se lanza el tipo de excepción de excepción, se declara que el método arroja todas las excepciones. Se pueden dividir múltiples excepciones usando comas. El formato de sintaxis de la declaración de lanzamientos es:
MethodName lanza Exception1, Exception2, .., Exceptionn {} Lanza después del nombre del método Exception1, Exception2, ..., ExceptionN es la lista de excepciones que se lanzarán. Cuando un método lanza una lista de excepciones de excepciones, el método no manejará excepciones de estos tipos y sus tipos de subclase, pero se lanzará al método que llama al método y será manejado por él. Por ejemplo:
import java.lang.Exception; public class testException {static void pop () lanza negativeRearRaysizeException {// Definir el método y tirar la excepción de NegatiMearRayeException int [] arr = new int [-3]; // Crear una matriz} public static void main (string [] args) {// método principal intenta {// prueba de instrucción maneja la información de excepción pop (); // Llame al método pop ()} Catch (negativeRArraSizeException e) {System.out.println ("Excepción lanzada por el método pop ()"); // Información de excepción de salida}}}Después de lanzar la excepción a la persona que llama usando la palabra clave de lanzamiento, si la persona que llama no quiere manejar la excepción, puede continuar tirando, pero al final debe haber una persona que llama que puede manejar la excepción.
El método POP no maneja la excepción de NegatiVearRaysizeException, sino que la función principal maneja.
La regla de lanzamientos para lanzar excepciones:
1) Si se trata de una excepción sin control, es decir, Error, RuntimeException o sus subclases, puede declarar la excepción que se lanza sin usar la palabra clave de lanzamiento, y la compilación aún pasará sin problemas, pero el sistema lo lanzará en tiempo de ejecución.
2) Cualquier excepción verificada que pueda ser lanzada por el método debe ser declarada. Es decir, si un método puede tener una excepción a verificación, se atrapará con una declaración de prueba de prueba o lo lanzará con una declaración de cláusula de lanzamiento, de lo contrario causará un error de compilación.
3) Solo cuando se lanza una excepción, la persona que llama del método debe manejar o rehacer la excepción. Cuando la persona que llama no puede manejar la excepción, debe continuar lanzándolo en lugar de tragarlo todo.
4) El método de llamadas debe seguir cualquier regla de manejo de excepciones y declaraciones de excepción. Si se sobrescribe un método, no se pueden declarar excepciones diferentes del método sobrescribido. Cualquier excepción declarada debe ser una o subclase similar o una subclase de la excepción declarada por el método anulado.
Por ejemplo:
Void Method1 () lanza IOException {} // Legal // Error de compilación, IOException debe ser atrapado o declarado para lanzar Method2 () {Method1 (); } // Legal, declare para lanzar IOException void Method3 () lanza IOException {Method1 (); } // Legal, declare para lanzar una excepción, IOException es una subclase de excepción void Method4 () lanza la excepción {Method1 (); } // legal, captura ioexception void métode5 () {try {métod1 (); } Catch (IOException e) {…}} // Error de compilación, debe atrapar o declarar la excepción lanzada void Method6 () {try {método1 (); } catch (ioException e) {Throw New Exception ();}} // Legal, declare Show Exception void Method7 () lanza Exception {try {Method1 (); } Catch (ioException e) {tire nueva excepción ();}} La base para determinar que puede ocurrir una excepción en un método es la siguiente:
1) Hay una declaración de lanzamiento en el método. Por ejemplo, el bloque de código de captura del método de método 7 () anterior tiene una declaración de lanzamiento.
2) Se llaman otros métodos, y otros métodos usan la cláusula de lanzamiento para declarar alguna excepción para lanzar. Por ejemplo, el método Method3 () llama al método Method1 (), y el método Method1 () declara que se lanza una IOException, por lo que puede ocurrir una IOException en el método Method3 ().
2. Use la excepción de lanzamiento para lanzar
El lanzamiento siempre aparece en el cuerpo de la función y se usa para lanzar una excepción de tipo que se puede lanzar. El programa terminará inmediatamente después de la declaración de lanzamiento, la declaración después de no se puede ejecutar, y luego en todos los bloques de try que lo contienen (tal vez en la función de llamadas de nivel superior) busque bloques de try que contengan la cláusula de captura que lo coincide de adentro hacia afuera.
Sabemos que las excepciones son objetos de instancia de clase de excepción, y podemos crear objetos de instancia de clase de excepción que se lanzarán a través de la declaración de lanzamiento. El formato de sintaxis de esta declaración es:
arrojar un nuevo nombre de excepción;
Por ejemplo, arroje un objeto de excepción de la clase IOException:
tirar nueva IOException;
Cabe señalar que lanza solo objetos de instancia que pueden lanzar una clase tirada o subclases. La siguiente operación es incorrecta:
tirar nueva cadena ("excepción");Esto se debe a que la cadena no es una subclase de la clase lanzable.
Si se lanza una excepción de verificación, también debe declarar el tipo de excepción que el método puede lanzar en el encabezado del método. La persona que llama de este método también debe verificar para manejar la excepción lanzada.
Si todos los métodos arrojan la capa de excepción adquirida por capa, el JVM eventualmente la procesará, y el procesamiento también es muy simple, que es imprimir el mensaje de excepción y la información de la pila. Si se lanza un error o RuntimeException, la persona que llama tiene la opción de manejar la excepción.
prueba de paquete; import java.lang.Exception; Public Class TestException {static int quotient (int x, int y) lanza myException {// Definir método para lanzar una excepción si (y <0) {// determina si el parámetro es menor que 0 tirar nueva myException ("El divisor no puede ser un número negativo"); // Información de excepción} return x/y; // Valor de retorno} public static void main (string args []) {// método principal int a = 3; int b = 0; Prueba {// Prueba la instrucción contiene declaraciones que pueden tener excepciones int resultado = cuidadora (a, b); // Cit de método de llamada citaente ()} Catch (MyException e) {// manejar la excepción personalizada System.out.println (e.getMessage ()); // Información de excepción de salida} Catch (arithmeticException e) {// manejar arithmeticexception excepción system.out.println ("divorceipt no puede ser 0"); // Información de solicitud de salida} Catch (Exception e) {// manejar otras excepciones System.out.println ("Otras excepciones ocurrieron en el programa"); // Información de solicitud de salida}}} La clase MyException extiende la excepción {// Crear mensaje de cadena de clase de excepción personalizada; // Definir el tipo de cadena Variable public MyException (String ErrorMesSagr) {// Método de clase principal Message = errorMessagr; } public String getMessage () {// anular getMessage () Method Devuelve Mensaje; }}3.3 cadena de excepción
1) Si se llama al cociente (3, -1), se producirá una excepción de MyException y el programa se transferirá al bloque de código Catch (MyException e) para ejecutar;
2) Si se llama al cociente (5,0), se planteará una excepción de ArithmeticException debido al error "divisor es 0". Pertenece a la clase de excepción de tiempo de ejecución y es lanzada automáticamente por el sistema de tiempo de ejecución Java. El método de cociente () no atrapa la excepción de arithmeticException. El sistema de tiempo de ejecución de Java buscará el método principal a lo largo de la pila de llamadas de método y cargará la excepción lanzada al llamado del método de cociente ():
int result = cuitiat (a, b); // Cociente de método de llamada ()
Dado que esta declaración se encuentra en el área de monitoreo de intentos, el sistema de tiempo de ejecución Java se retira la ArithmeticException con "divisor es 0".
Catch (arithmeticException e) {// manejar arithmeticException Exception System.out.println ("El divisor no puede ser 0"); // Información de solicitud de salida}El resultado de procesamiento es que el "divisor de salida no puede ser 0". Java, un mecanismo de procesamiento que pasa información de excepción hacia arriba, forma una cadena de excepciones.
La excepción de control realizada por el método Java se pasará al método de llamadas con la capacidad de procesamiento basada en la pila de llamadas y a lo largo de la jerarquía de la llamada del método, y el nivel más alto será hasta el método principal. Si la excepción se pasa al método principal, pero el principal no tiene la capacidad de manejarlo y no lanza la excepción a través de la declaración de lanzamientos, puede ocurrir un error de compilación.
3) Si se producen otras excepciones, la captura (excepción e) se usará para atrapar. Since Exception is the parent class of all exception classes, if the catch (Exception e) code block is placed in front of the other two code blocks, the subsequent code blocks will never be executed, which makes no sense, so the order of catch statements cannot be replaced.
3.4 Throwable类中的常用方法
注意：catch关键字后面括号中的Exception类型的参数e。Exception就是try代码块传递给catch代码块的变量类型，e就是变量名。catch代码块中语句"e.getMessage();"用于输出错误性质。通常异常处理常用3个函数来获取异常的有关信息:
getCause()：返回抛出异常的原因。如果cause 不存在或未知，则返回null。
getMeage()：返回异常的消息信息。
printStackTrace()：对象的堆栈跟踪输出至错误输出流，作为字段System.err 的值。
有时为了简单会忽略掉catch语句后的代码，这样try-catch语句就成了一种摆设，一旦程序在运行过程中出现了异常，就会忽略处理异常，而错误发生的原因很难查找。
5.Java常见异常
在Java中提供了一些异常用来描述经常发生的错误，对于这些异常，有的需要程序员进行捕获处理或声明抛出，有的是由Java虚拟机自动进行捕获处理。Java中常见的异常类:
1. runtimeException子类:
1、 java.lang.ArrayIndexOutOfBoundsException
数组索引越界异常。当对数组的索引值为负数或大于等于数组大小时抛出。
2、java.lang.ArithmeticException
算术条件异常。譬如：整数除零等。
3、java.lang.NullPointerException
空指针异常。当应用试图在要求使用对象的地方使用了null时，抛出该异常。譬如：调用null对象的实例方法、访问null对象的属性、计算null对象的长度、使用throw语句抛出null等等
4、java.lang.ClassNotFoundException
找不到类异常。当应用试图根据字符串形式的类名构造类，而在遍历CLASSPAH之后找不到对应名称的class文件时，抛出该异常。
5、java.lang.NegativeArraySizeException 数组长度为负异常
6、java.lang.ArrayStoreException 数组中包含不兼容的值抛出的异常
7、java.lang.SecurityException 安全性异常
8、java.lang.IllegalArgumentException 非法参数异常
2.IOException
IOException：操作输入流和输出流时可能出现的异常。
EOFException 文件已结束异常
FileNotFoundException 文件未找到异常
3. 其他
ClassCastException 类型转换异常类
ArrayStoreException 数组中包含不兼容的值抛出的异常
SQLException 操作数据库异常类
NoSuchFieldException 字段未找到异常
NoSuchMethodException 方法未找到抛出的异常
NumberFormatException 字符串转换为数字抛出的异常
StringIndexOutOfBoundsException 字符串索引超出范围抛出的异常
IllegalAccessException 不允许访问某类异常
InstantiationException 当应用程序试图使用Class类中的newInstance()方法创建一个类的实例，而指定的类对象无法被实例化时，抛出该异常
6.自定义异常
使用Java内置的异常类可以描述在编程时出现的大部分异常情况。除此之外，用户还可以自定义异常。用户自定义异常类，只需继承Exception类即可。
在程序中使用自定义异常类，大体可分为以下几个步骤。
（1）创建自定义异常类。
（2）在方法中通过throw关键字抛出异常对象。
（3）如果在当前抛出异常的方法中处理异常，可以使用try-catch语句捕获并处理；否则在方法的声明处通过throws关键字指明要抛出给方法调用者的异常，继续进行下一步操作。
（4）在出现异常方法的调用者中捕获并处理异常。
在上面的“使用throw抛出异常”例子已经提到了。
Lo anterior es todo el contenido de este artículo. Espero que sea útil para el aprendizaje de todos y espero que todos apoyen más a Wulin.com.