Prefacio
Al escribir programas Java, es fundamental comprender cómo manejar las excepciones. El manejo de excepciones puede ayudarnos a manejar varias condiciones de error durante la ejecución del programa para garantizar que el programa pueda ejecutarse normalmente o salir correctamente. Este artículo presentará algunos conceptos básicos y mejores prácticas sobre el manejo de excepciones de Java, incluidas clases de excepciones personalizadas, procesamiento de entradas de usuarios, captura y procesamiento de excepciones, impresión de información de excepciones, uso de estructuras, orden de captura de excepciones, lanzamiento de excepciones y uso de try-catch-finallydeclaraciones throws. , recursividad que provoca desbordamiento de pila y excepciones personalizadas.
Notas de estudio orientadas a objetos de Java-1
Notas de estudio orientadas a objetos de Java-2
Notas de estudio orientadas a objetos de Java-3
1. Clase de excepción personalizada
Primero, veamos cómo crear una clase de excepción personalizada. En Java, podemos heredar las clases integradas Exceptionpara crear nuestras propias clases de excepción. Esta clase de excepción personalizada se puede utilizar para generar y detectar excepciones personalizadas.
package cn.dfjy.demo;
public class MyException extends Exception {
public MyException(String msg) {
super(msg);
}
}
2. Entrada básica del usuario
La entrada del usuario es parte de la mayoría de las aplicaciones Java. A continuación se muestra un ejemplo de cómo usar Scanneruna clase para leer un número entero ingresado por el usuario desde la consola.
package cn.dfjy.demo;
import java.util.Scanner;
public class Test {
public static void main(String[] args) {
//System.out.println(args[0]);
Scanner scanner = new Scanner(System.in);
/*
异常也是一个类
java.util.InputMismatchException
java.lang.NullPointerException
java.lang.ArrayIndexOutOfBoundsException
java.lang.ArithmeticException
*/
System.out.println("请输入一个数字：");
int number = scanner.nextInt();
System.out.println("数字是：" + number);
System.out.println("程序结束");
}
}
3. Conceptos básicos del manejo de excepciones
Al manejar la entrada del usuario, debemos verificar que el usuario haya proporcionado el tipo de datos correcto. Esto se puede hasNextInt()lograr mediante métodos.
package cn.dfjy.demo;
import java.util.Scanner;
public class Test02 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/*
解决异常的思路：
使用if判断
*/
System.out.println("请输入一个数字：");
if (scanner.hasNextInt()) {
// 判断是否缓冲区（键盘）接收到一个数字
int number = scanner.nextInt();
System.out.println("数字是：" + number);
} else {
System.out.println("请输入正确的数字！");
}
}
}
4. Utilice Try-Catch para manejar excepciones
Las excepciones son una señal de que puede ocurrir un error y podemos usar try-catchbloques para manejar excepciones y garantizar que el programa no falle cuando encuentre un problema.
package cn.dfjy.demo;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Test03 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/*
解决异常的思路：
使用异常机制 try catch
*/
try {
System.out.println("请输入一个数字（分子）：");
int number1 = scanner.nextInt();
System.out.println("请输入一个数字（分母）：");
int number2 = scanner.nextInt();
System.out.println(number1 + "/" + number2 + "=" + number1/number2);
} catch (InputMismatchException ex) {
System.out.println("请输入正确的数字！");
} catch (ArithmeticException ex) {
System.out.println("分母不能为零！");
}
}
}
5. Imprimir información de excepción
En el manejo de excepciones, generalmente queremos poder registrar o imprimir los detalles de la excepción para problemas de depuración y seguimiento.
package cn.dfjy.demo;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Test04 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/*
解决异常的思路：
使用异常机制 try catch
*/
try {
System.out.println("请输入一个数字（分子）：");
int number1 = scanner.nextInt();
System.out.println("请输入一个数字（分母）：");
int number2 = scanner.nextInt();
System.out.println(number1 + "/" + number2 + "=" + number1/number2);
} catch (InputMismatchException ex) {
ex.printStackTrace(); // 打印异常的栈信息
// System.out.println(ex.getMessage()); // 打印异常的信息：null
} catch (ArithmeticException ex) {
// ex.printStackTrace(); // 打印异常的栈信息
System.out.println(ex.getMessage()); // 打印异常的信息：/ by zero
}
System.out.println("程序结束");
}
}
6. Utilice Try-Catch-Finally para manejar excepciones
En algunos casos, debemos asegurarnos de que los recursos se liberen correctamente, incluso si se produce una excepción. En este momento, podemos usar try-catch-finallyestructuras.
package cn.dfjy.demo;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Test05 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/*
解决异常的思路：
使用异常机制 try catch finally
面试：
1. finally代码块不执行的唯一条件
虚拟机结束
*/
try {
System.out.println("请输入一个数字（分子）：");
int number1 = scanner.nextInt();
System.out.println("请输入一个数字（分母）：");
int number2 = scanner.nextInt();
System.out.println(number1 + "/" + number2 + "=" + number1/number2);
System.exit(0); // Terminates the currently running Java Virtual Machine 结束当前java虚拟机
System.out.println("return");
return; // 也挡不住 finally 的执行
} catch (InputMismatchException ex) {
System.out.println(ex.getMessage()); // 打印异常的信息：null
} catch (ArithmeticException ex) {
System.out.println(ex.getMessage()); // 打印异常的信息：/ by zero
} finally {
// 最终
System.out.println("try块中涉及的资源释放");
}
System.out.println("程序结束");
}
}
7. Secuencia de captura de excepciones
Java nos permite detectar múltiples excepciones, pero debemos prestar atención a su orden. Java elegirá el primer catchbloque coincidente para su ejecución, por lo que catchel orden de los bloques es importante.
package cn.dfjy.demo;
import java.util.InputMismatchException;
import java.util.Scanner;
public class Test06 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/*
解决异常的思路：
使用异常机制 try catch finally
catch顺序
1. 没有继承关系的，谁先谁后，都可以
2. 有继承关系的，记住父亲在后 Exception 兜底
*/
try {
System.out.println(args[0]);
System.out.println("请输入一个数字（分子）：");
int number1 = scanner.nextInt();
System.out.println("请输入一个数字（分母）：");
int number2 = scanner.nextInt();
System.out.println(number1 + "/" + number2 + "=" + number1/number2);
} catch (ArithmeticException ex) {
System.out.println(ex.getMessage()); // 打印异常的信息：/ by zero
} catch (InputMismatchException ex) {
System.out.println(ex.getMessage()); // 打印异常的信息：null
} catch (Exception ex) {
System.out.println(ex.getMessage());
} finally {
// 最终
System.out.println("try块中涉及的资源释放");
}
System.out.println("程序结束");
}
}
8. Lanzar una excepción
En Java, podemos throwgenerar excepciones en métodos usando palabras clave.
package cn.dfjy.demo;
import java.util.Scanner;
public class Test07 {
public static void main(String[] args) throws Exception {
Scanner scanner = new Scanner(System.in);
/*
解决异常的思路：
使用异常机制 try catch finally throw throws
throw，用于方法体内代码行
throws，用于方法声明上，跟在方法的后面一点
*/
throw new Exception();
}
}
9. Úselo throwspara declarar excepciones.
En los métodos, podemos usar throwspalabras clave para declarar excepciones que pueden generarse, de modo que la persona que llama sepa que estas excepciones deben manejarse.
Las excepciones en Java se pueden dividir en dos categorías principales: excepciones marcadas y excepciones de tiempo de ejecución (excepciones no marcadas).
-
Excepciones marcadas :
- Estas excepciones son excepciones obligatorias que deben manejarse en tiempo de compilación y deben detectarse
try-catchmediante un bloque othrowsdeclararse mediante la palabra clave en la firma del método para generar la excepción. - Suele utilizarse para indicar problemas causados por factores externos que puede encontrar el programa, como inexistencia de archivos, problemas de conexión de red, etc.
- Ejemplos:
IOException,SQLException,ClassNotFoundExceptionetc.
- Estas excepciones son excepciones obligatorias que deben manejarse en tiempo de compilación y deben detectarse
-
Excepciones en tiempo de ejecución (excepciones no marcadas) :
- Estas excepciones generalmente son causadas por errores de lógica del programa y no es necesario forzar su manejo en el momento de la compilación.
- Generalmente se usa para indicar errores de programación, como excepciones de puntero nulo, excepciones de matriz fuera de límites, etc.
- Ejemplos:
NullPointerException,ArrayIndexOutOfBoundsException,ArithmeticExceptionetc.
La elección de qué tipo de excepción utilizar depende de la naturaleza de la excepción. Si la excepción es causada por factores externos incontrolables, debe utilizar excepciones marcadas. Las excepciones de tiempo de ejecución generalmente se usan si la excepción se debe a un error del programa. Esto ayuda a que el código sea más legible y fácil de mantener, y ayuda a los desarrolladores a manejar mejor las excepciones.
package cn.dfjy.demo;
import java.util.Scanner;
public class Test08 {
public static void main(String[] args) {
Scanner scanner = new Scanner(System.in);
/*
解决异常的思路：
使用异常机制 try catch finally throw throws
throw，用于方法体内代码行
throws，用于方法声明上，跟在方法的后面一点
*/
try {
f01(-100);
} catch (Exception e) {
System.out.println(e.getMessage());
}
f02(-100);
System.out.println("代码正常走完");
}
public static void f01(int cj) throws Exception {
if (cj < 0) throw new Exception("成绩不能为负数！"); // 必检异常（排除掉RuntimeException或它的子类）
System.out.println("成绩：" + cj);
}
public static void f02(int cj) {
if (cj < 0) throw new RuntimeException("成绩不能为负数！"); // 运行期异常
System.out.println("成绩：" + cj);
}
}
Cuando escribe un programa Java, a veces ocurrirán algunos problemas o errores, estos problemas se denominan excepciones. Las excepciones pueden ser de diferentes tipos y estas dos funciones f01son f02ejemplos de cómo manejan las excepciones de manera diferente.
-
f01Lo que arroja la función es un problema llamado "excepción marcada". Es como cuando estás escribiendo una tarea, si hay un problema tienes que resolverlo o tu tarea no se aprobará. En este caso, debe manejar la excepción, ya sea con un código especial (try-catch) o decirle a otros (en la firma del métodothrows) que este problema puede ocurrir. -
f02Lo que arroja la función es un problema llamado "excepción de tiempo de ejecución". Es como cuando estás jugando, si cometes un pequeño error, el juego no se detendrá inmediatamente, sino que te avisará. En este caso, puede optar por solucionar el problema, pero no es necesario: el programa no se detendrá inmediatamente debido a este problema.
Entonces, la principal diferencia es la forma en que se tratan estas excepciones. Las excepciones requeridas requieren que las manejes explícitamente en tu código, mientras que las excepciones en tiempo de ejecución son opcionales. Puede elegir qué tipo de excepción utilizar según la naturaleza de su problema.
10. La recursividad provoca el desbordamiento de la pila.
La recursividad es una técnica de programación útil, pero sin la condición de terminación correcta, puede provocar un desbordamiento de la pila.
package cn.dfjy.demo;
public class Test09 {
public static void main(String[] args) {
main(args); // java.lang.StackOverflowError
System.out.println("结束！");
}
}
11. Excepciones personalizadas
Finalmente, podemos crear nuestra propia excepción personalizada y lanzarla en el método, y luego maincapturarla y manejarla en el método.
package cn.dfjy.demo;
public class Test10 {
public static void main(String[] args) {
try {
f01("公");
} catch (MyException e) {
System.out.println(e.getMessage());
}
System.out.println("正常结束");
}
public static void f01(String sex) throws MyException {
if (!"男".equals(sex) && !"女".equals(sex)) throw new MyException("性别必须是男或女");
System.out.println("性别正确");
}
}
Resumir
Estos ejemplos proporcionan conceptos básicos y aplicaciones prácticas de manejo de excepciones en Java. Al estudiar estos ejemplos, podrá comprender mejor cómo utilizar el manejo de excepciones para crear programas Java sólidos. El manejo de excepciones es una parte clave de la escritura de código mantenible de alta calidad, por lo que es valioso asegurarse de dominar estos conceptos.