Manejo de excepciones de Java
Uno, el concepto
de excepción 1, excepción (excepción) es una excepción que ocurre en la secuencia de código durante la operación.
2. Jerarquía de la clase de
excepción Todas las clases de excepción son subclases heredadas de la clase java.lang.Exception.
La clase Exception es una subclase de la clase Throwable. Además de la clase Exception, Throwable también tiene una subclase Error.
Los programas Java normalmente no detectan errores. Los errores generalmente ocurren cuando ocurren fallas graves y están fuera del alcance del programa Java.
Error se utiliza para indicar que ocurrió un error en el entorno de ejecución.
La clase de excepción tiene dos subclases principales: clase IOException y clase RuntimeException.
Dos, tipos de excepciones comunes
Tres, manejo de excepciones El manejo de excepciones de
Java está controlado por 5 palabras clave: try, catch, throw, throws y finalmente.
1. Estructura Try-catch
try { código A código B } catch (ExceptionType e) { código de manejo de excepciones C } código D expectativa: A—> B—> C—> D cuando el programa no tiene excepciones. En realidad: A—> Manejo de excepciones—> C—> El código D B es anormal En realidad: A—> B—> Manejo de excepciones—> C—> El código D B es anormal 2, finalmente palabra clave
A veces, se hace referencia a algunos recursos físicos en el bloque try, como conexiones de base de datos, conexiones de red o archivos de disco. Una vez que se produce una excepción en el bloque try, no se puede garantizar la liberación de estos recursos.
Debe haber una forma muy precisa de Asegúrese de que los recursos sean ciertos. Obtenga la liberación, independientemente de si hay una excepción, que es la razón por la que finalmente existe.
ry { código A código B } catch (ExceptionType e) { código de manejo de excepciones C } finalmente { código de reciclaje código de recurso D } código E
Tenga en cuenta lo siguiente: la
captura no puede existir independientemente del intento.
No es obligatorio agregar un bloque finalmente después de intentar / atrapar.
No puede haber ni un bloque de captura ni un bloque de finalmente después del código de prueba.
No se puede agregar código entre los bloques try, catch y finalmente.
Visualización de código:
package exception;
public class ArithmeticException {
public static void main(String[] args) {
//算数错误
try {
int num=5/0; //出现异常
System.out.println(num); // 异常后的程序不再执行
}catch (java.lang.ArithmeticException e){
//捕捉异常
System.out.println("除数不能为零"); //处理异常
}finally {
System.out.println("资源回收"); //资源回收
}
System.out.println("helloworld"); //后面的程序继续执行
//试图访问null对象引用
try {
String str = null; //定义一个空的字符串
System.out.println(str.length()); //输出空字符串长度，出现异常
}catch (NullPointerException c){
//捕捉异常
c.printStackTrace(); //打印异常
System.out.println("不能为空"); //处理异常
}finally {
System.out.println("回收资源"); //回收资源
}
System.out.println("程序继续执行"); //后面的程序继续执行
}
}
Resultados de ejecución:
3, múltiples bloques de captura
try { code A try { code A1 code B1 code C1 } catch (ExceptionType2 e2) { código de manejo de excepciones D2 } código C } catch (ExceptionType2 e2) { código de manejo de excepciones D1 } finalmente { código de recurso de reciclaje E } código F
El fragmento de código anterior contiene 3 bloques de captura.
Puede agregar cualquier número de bloques de captura después de la instrucción try.
Si ocurre una excepción en el código de protección, la excepción se lanza al primer bloque de captura.
Si el tipo de datos de la excepción lanzada coincide con ExceptionType1, se detectará aquí.
Si no coincide, se pasará al segundo bloque de captura.
Entonces, hasta que se capture la excepción o atraviese todos los bloques de captura.
Visualización de código:
package exception;
import java.lang.ArithmeticException;
public class MultiplAanomalies {
public static void main(String[] args) {
try {
int i=5/1; //语句正确，正常执行
System.out.println(i);
try {
int num = 5/0; //出现异常
System.out.println(num); //异常语句后面的代码不再执行
String str = null;
System.out.println(str.length());
}catch (ArithmeticException c){
//捕捉异常
System.out.println("出现异常啦");
}catch (NullPointerException c){
System.out.println("出现异常");
}
}catch (Exception c){
System.out.println("出现异常了");
}finally {
System.out.println("资源回收");
}
System.out.println("程序继续执行");
}
}
Resultados de la ejecución:
3. Lanzar y lanzar palabras clave
(1), lanzar palabra clave
A veces, es necesario generar una excepción explícitamente y el lenguaje Java puede generar una excepción explícitamente con la declaración throw.
Una vez que el flujo de ejecución encuentra una instrucción throw, se detendrá inmediatamente y la siguiente instrucción no se ejecutará.
En pocas palabras, es para personalizar una excepción
(2). La palabra clave
throws throws sigue el método, lo que indica que el método puede lanzar algunas o algunas excepciones, y este método no le importa o es inconveniente de manejar, y es llamado por el método Para manejar estas excepciones.
Visualización de código:
package Throw;
//自定义异常类，继承Exception类
public class MyExcertion extends Exception{
public MyExcertion(){
//无参构造方法
super();
}
public MyExcertion(String a){
//有参构造方法
super(a);
}
}
package Throw;
public class Test1 {
public static void main(String[] args) {
try {
show();
} catch (MyExcertion myExcertion) {
myExcertion.printStackTrace(); //打印异常
System.out.println("出现异常");
}
}
public static void show() throws MyExcertion{
if (2>1){
//自定义异常，比如去银行取钱，取款金额大于卡内余额则会显示余额不足（相当于出现异常）。
throw new MyExcertion();
}
}
}
Resultados de la operación:
Cuarto, reglas de uso de excepción
No establezca try and catch para cada declaración que pueda ser anormal. Aunque el uso de excepciones puede separar el código convencional y el código de manejo de errores, mejorando así la legibilidad del código, el uso inadecuado de las excepciones reducirá la legibilidad del código.
Evite siempre capturar Exception o Throwable, pero capture la clase de excepción específica. Esto puede hacer que el programa sea más claro.
¿En qué circunstancias se utilizan las excepciones? Si el método encuentra una condición anormal que no sabe cómo manejar, entonces debería lanzar una excepción.
No use try ... catch in the loop, intente poner try ... catch fuera del ciclo o evite usarlo.
El manejo de excepciones no debe usarse para controlar el flujo normal del programa. No considere las excepciones como "super if