Captura y manejo anormales
Java es poderoso para manejar excepciones
Reconocer el impacto de las anomalías en el programa.
La excepción se refiere al flujo de instrucciones que provocó la interrupción del programa.
Después de que ocurra el error, todo el programa no se ejecutará de la manera prevista, pero se interrumpirá la ejecución. Con el fin de garantizar que el programa aún se pueda completar normalmente después de que ocurra un error no fatal, para garantizar el progreso sin problemas del programa.
Manejar excepción
El manejo de excepciones en Java se puede lograr usando las palabras clave try, catch y finalmente. La estructura de procesamiento básica es la siguiente:
try{
// 可能出现异常的语句
}[catch (异常类型 异常对象){
// 异常处理
}
catch (异常类型 异常对象){
// 异常处理
}...][finally{
// 不管异常是否处理都要执行
}]
Combinaciones que se pueden usar: probar ... atrapar, probar ... atrapar ... finalmente, probar ... finalmente.
En este momento, cuando se maneja la excepción, la salida es un objeto de la clase de excepción, por lo que si el objeto se imprime directamente, la información de excepción obtenida está incompleta. Si desea obtener la información de excepción completa, puede utilizar el método printStackTrace () proporcionado en la clase de excepción para completar.
Para el formato de manejo de excepciones, también se puede agregar un bloque finalmente al final para indicar la salida del manejo de excepciones, independientemente de si el programa es anormal o no.
Manejo de múltiples excepciones
Se generan varias excepciones, en este caso, las capturas múltiples también se pueden utilizar para capturar excepciones.
Tipo de excepción:
- Olvidé ingresar parámetros: excepción de matriz fuera de límites
- Error de tipo de entrada: formato de número anormal
- Datos anómalos: el dividendo no debe ser 0
Proceso de manejo de excepciones
Al realizar el manejo de excepciones, se capturan todas las excepciones que se sabe claramente que se generaron. Aunque se puede obtener una buena estructura de código, este tipo de escritura de código es muy problemático, por lo que si desea hacer una excepción razonable, debe borrar después de que se genera la excepción ¿Qué hizo el programa?
- Las excepciones solo ocurrirán durante la ejecución del programa, y una vez que ocurra una excepción durante la ejecución del programa, el tipo especificado de objeto de clase de excepción se instanciará automáticamente;
- Si el programa no proporciona soporte para el manejo de excepciones en este momento, utilizará el manejo de excepciones predeterminado de la JVM, primero imprimirá la información de la excepción y luego saldrá de la ejecución;
- Si el programa proporciona manejo de excepciones en este momento, entonces el objeto instanciado de la clase de excepción generada será capturado por la instrucción try;
- Después de que try detecta la excepción, realiza una comparación con el tipo de excepción de captura coincidente; si coincide, la captura se utiliza para el manejo de excepciones. Si no hay una coincidencia exitosa, significa que la excepción no se puede manejar;
- Finalmente, se ejecuta la sentencia finalmente. Una vez finalizada la sentencia, se juzgará si la excepción actual se ha procesado, si se procesa, continuará ejecutándose y si no se procesa, se entregará. a la JVM para el procesamiento predeterminado.
En todo el manejo de excepciones, la operación real sigue siendo un objeto instanciado de una clase de excepción, por lo que el tipo de objeto instanciado de esta clase de excepción se convierte en la clave principal para comprender el manejo de excepciones.
El tipo de excepción más grande que se puede manejar en un programa es Throwable, que tiene dos subcategorías:
- Error: el error ocurrió cuando el programa no se ha ejecutado en este momento y no se puede procesar durante el desarrollo.
- Excepción: el desarrollador puede ocuparse de la excepción en el programa.
A través del análisis, se puede encontrar que el objeto instanciado que producirá una excepción cuando ocurre una excepción, luego de acuerdo con el principio de referencia de objeto, se puede transformar automáticamente a la clase padre. De acuerdo con esta lógica, todas las excepciones pueden ser manejadas por Excepción.
catch(Exception e){
e.printStackTrace();
}
Cuando no está seguro de qué excepciones se generan, es fácil de manejar. El problema a tratar es que la descripción de la información del error no es clara. Por lo tanto, el manejo separado de las excepciones es una forma más conveniente y clara de manejar.
Cuando se procesen varias excepciones al mismo tiempo en el futuro, la excepción con un rango de captura grande debe colocarse después de la excepción con un rango de captura pequeño.
lanza palabra clave
A través del programa anterior, se puede generar una excepción en la ejecución del programa, asumiendo que se define un método, se debe indicar claramente al usuario qué excepción se generará. En este punto, puede usar la palabra clave throws en la declaración del método para marcar el tipo de excepción.
class Math{
//这个代码执行时可能会产生算术异常,如果产生异常"调用处"处理
public static int div(int x, int y) throws ArithmeticException{
return x/y;
}
}
main throws Exception{
//主方法向上抛出异常
Math.div(10,2);
}
El método principal en sí mismo también es un método, y las excepciones generadas también se pueden lanzar hacia arriba; significa que la JVM es responsable de manejar las excepciones.
lanzar palabra clave
Lanzar significa lanzar manualmente una excepción. En este momento, se genera manualmente un objeto instanciado de la excepción y se lanza la excepción.
main{
try{
//异常对象是手工定义的
throw new Exception("自己跑着玩的对象。");
} catch(Exception e){
e.printStackTrace();
}
}
Entrevista: ¿Explica la diferencia entre lanzamientos y lanzamientos?
- lanzar: se utiliza en bloques de código, principalmente para lanzar manualmente objetos de excepción;
- Throws: se usa en la definición del método, lo que significa que las excepciones que este método puede producir se indican claramente al lugar de la llamada y son manejadas por el lugar de la llamada.
Modelo de manejo de excepciones
class Math{
//这个代码执行时可能会产生异常,如果产生异常"调用处"处理
public static int div(int x, int y) throws Exception{
int temp = 0;
print("start");
try{
temp = x/y;
} catch(Exception e){
throw e; //向上抛异常对象
} finally{
print("end");
}
return temp;
}
}
main{
try{
Math.div(10,2);
} catch (Exception e){
e.printStackTrace();
}
}
Para este tipo, se puede omitir la captura en Math. Este tipo de formato de manejo de excepciones es muy importante en el desarrollo real (para el acceso a recursos).
Excepción en tiempo de ejecución
Siempre que el método tenga lanzamientos, le dirá al usuario qué tipo de excepción ocurrió.
Si la ejecución del programa actual requiere que el desarrollador procese manualmente siempre que se use el método definido por throws, el código es demasiado engorroso, por lo que en el proceso de diseño, se proporciona una excepción opcional flexible que maneja la clase principal "RuntimeException". Subclases de excepciones puede que no requiera manipulación obligatoria.
Entrevista: ¿Explique la diferencia entre RuntimeException y Exception? Muestra una RuntimeException común.
- RuntimeException es una subclase de Exception;
- La excepción marcada por RuntimeException no requiere un manejo obligatorio, mientras que la excepción Exception debe ser obligatoria.
- 常见 ： NumberFormatException 、 ClassCastException 、 NullPointerException
Clase de excepción personalizada
El JDK proporciona una gran cantidad de tipos de excepciones, que pueden no ser suficientes en el desarrollo real. En este momento, considere los tipos de excepciones personalizados.
Dos esquemas de implementación: heredar Exception o RuntimeException;
class BombException extends Exception{
public BombException(String msg){
super(msg);
}
}
class Food{
public static void eat(int num) throws BombException{
if(num > 10 ){
throw new BombException("TOO MUCH");
} else{
print("normal");
}
}
}
afirmar
Después de JDK1.4, se agrega una función de aserción para confirmar que el código debe ser el resultado esperado después de ejecutar una determinada línea. La aserción de desarrollo real puede no ser correcta y puede haber desviaciones, pero esta desviación no debería afectar la ejecución normal. Del programa.
La afirmación no se establece como un paso que un programa debe ejecutar en Java y se puede activar en un entorno específico.