Todos pueden estar familiarizados con las excepciones. Al probar un programa, los comportamientos anormales que ocurren durante el proceso de ejecución se denominan excepciones, y los caracteres rojos que aparecen son las manifestaciones de las excepciones. A través de este artículo, echemos un vistazo a las excepciones. Análisis. ¡Divídelo en las siguientes cuatro partes!
1. Reconocer anomalías
Hay muchos tipos de excepciones, y los diferentes tipos tienen diferentes métodos de manejo.
1.1 Ejemplos de excepciones comunes
a.Cuando el divisor es 0. (Excepción aritmética)
Todo el mundo debe saber que el divisor no puede ser 0. Al escribir el código, si el divisor se escribe como 0 por error, se informará una excepción. No hay mucho que decir, vaya a el código.
System.out.println(3/0);
//执行后你会发现这样一行红色的代码
Exception in thread "main" java.lang.ArithmeticException: / by zero
ArithmeticException es una excepción aritmética. El / por cero después de ArithmeticException: es la razón de su error: el divisor no puede ser 0.
b. Subíndice de matriz fuera de los límites (excepción de subíndice de matriz fuera de los límites)
Supongamos que la longitud de la matriz es 5, y el tamaño de la matriz es 5. El rango de acceso es [0,4], que comienza desde el subíndice 0 y termina en el subíndice (tamaño 1). Si accede más allá de este rango, verá el código rojo familiar nuevamente. Por ejemplo mi código a continuación.
int[] arr={
1,2,3,4,5};
System.out.println(arr[5]);
//执行后,不好意思,爆红了.
Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: 5
ArrayIndexOutOfBoundsException Subíndice de matriz fuera de los límites de excepción, esta excepción es muy común y la tasa de ocurrencia es bastante alta, si los hermanos no tienen cuidado al escribir el código, habrá errores.
c. Acceso a objetos nulos (excepción de puntero nulo).
public class Test{
int num=1;
public static void main(String[] args){
//让这个引用t指向null.
Test t=null;
System.out.println(t.num);
}
}
//执行后会出现异常
Exception in thread "main" java.lang.NullPointerException
NullPointerException es una excepción de puntero nulo.
Nota: Después de que ocurra una excepción en el programa, el código detrás de la excepción no se ejecutará.Demostración de
código:
System.out.println("hello world");
System.out.println(10/0);
System.out.println("hello,hello");
//执行结果
hello world
Exception in thread "main" java.lang.ArithmeticException: / by zero
1.2 Programación defensiva (por el momento)
Los errores existen objetivamente en el código, por lo que debemos notificar a los programadores a tiempo cuando hay un problema con el programa.
Tenemos dos formas principales. LBYL, EAFP
LBYL: Mira antes de saltar: haz una verificación completa antes de la operación.
EAFP : Es más fácil pedir perdón que permiso, hazlo primero y luego resuélvelo cuando encuentres un problema.
Por ejemplo, puedes entenderlo de un vistazo:
la primera situación: tú y tu hermana van a una casa embrujada, tú eres más cobarde y quieres tirar La mano de la niña va a preguntarle a la niña, espera a que la niña acepte y se toman de la mano (LBYL)
La segunda situación: la atención de la niña está muy concentrada En este momento, de repente tiras de su mano El problema es que ella está asustada y te da una bofetada. Otra disculpa es (EAFP).
La idea central de nuestra anomalía es EAFP.
2. Uso básico de las excepciones.
Manejemos las excepciones.
2.1 Captura de excepciones
//基本语法:
try{
//...
}catch(异常类型,异常对象){
//...
}finally{
//...
}
El bloque de código a.try es para el código que puede causar una excepción. El
bloque de código b.catch es para el comportamiento de procesamiento después de que ocurre la excepción.
El código en el bloque de código c.finally se usa para manejar las consecuencias y será ejecutado al final
D. Tanto catch como finalmente pueden agregarse o no según la situación.
Ejemplo 1: excepción no controlada
System.out.println("hello world");
System.out.println(10/0);
System.out.println("hello,hello");
//执行结果
hello world
Exception in thread "main" java.lang.ArithmeticException: / by zero
Ejemplo 2: Después de atrapar con try catch
try{
System.out.println("hello world");
System.out.println(10/0);
}catch(ArithmeticException e){
e.printStackTrace();
}
System.out.println("hello,hello");
//执行结果:
hello world
hello,hello
java.lang.ArithmeticException: / by zero
at demo01TimeAndSpace.Test.main(Test.java:7)
Se puede encontrar que la declaración de código que sigue a la excepción se puede ejecutar después de que se detecte la excepción.
2.2 Proceso de manejo de excepciones
a. El programa ejecuta el código en el intento primero.
b. Si el código en el intento tiene una excepción, finalizará el código en el intento para ver si coincide con el tipo de excepción en la captura.
c. Si una excepción coincidente se encuentra, se ejecutará la captura. El código en
d. Si no se encuentra ningún tipo de excepción coincidente, la excepción se pasará a la persona que llama superior.
e. Independientemente de si se encuentra un tipo de excepción coincidente, el código en finalmente se ejecutará (antes de que finalice el método) f.
Si la persona que llama de nivel superior no ha manejado la excepción, seguirá pasando.
g. Hasta que el método principal no tenga un código adecuado para manejar la excepción, se entregará a la JVM para su procesamiento y el programa terminará de forma anormal.
2.3 Lanzar excepciones
Además de las clases integradas de Java que lanzan excepciones, también podemos lanzar una excepción manualmente, usando la palabra clave throw para lograr
esto.Sintaxis:
throw new 异常类型(可以写一些注释);
manera de completar un x/y
public class Test {
public static int divide(int x,int y){
if (y==0){
throw new ArithmeticException("除数为 0 异常");
}
return x/y;
}
public static void main(String[] args) {
int num=divide(20,0);
System.out.println(num);
}
}
Cuando llamamos a este método y accidentalmente establecemos y en 0, sucede lo siguiente.
Exception in thread "main" java.lang.ArithmeticException: 除数为 0 异常
at demo01TimeAndSpace.Test.divide(Test.java:6)
at demo01TimeAndSpace.Test.main(Test.java:11)
2.4 Descripción de la excepción
Cuando manejamos excepciones, generalmente queremos saber qué posibles excepciones ocurrirán en este código.
Podemos usar la palabra clave throws para marcar explícitamente las excepciones que pueden arrojarse en la posición de la definición del método. Recordando así a la persona que llama que tenga cuidado de captura estas excepciones
Mira directamente el ejemplo:
public static int divide(int x,int y) throws ArithmeticException{
if (y==0){
throw new ArithmeticException("除数为 0 异常");
}
return x/y;
}
2.5 Notas sobre finalmente
El código finalmente está garantizado para ser ejecutado, pero también traerá algunos problemas, veamos un código.
public static int func() {
try {
return 10;
}finally {
return 20;
}
}
//方法被调用后结果为:
//20.
El momento de la ejecución de finalmente es antes de que el método regrese:
si hay un retorno en try o catch, finalmente se ejecutará antes del retorno.
Sin embargo, si también hay una declaración de retorno en finalmente, entonces se ejecutará el retorno en finalmente, por lo que no se ejecutará el retorno original en try.
Por lo tanto, generalmente no se recomienda escribir una declaración de retorno en finalmente.
3. Sistema anormal
a. La clase Throwable de nivel superior deriva de dos subclases importantes, Error y Exception
b. Error se refiere a errores internos del tiempo de ejecución de Java y errores de agotamiento de recursos. Las aplicaciones no lanzan tales excepciones. Una vez que ocurren tales errores internos, además de informar al usuario y haciendo que el programa termine, no hay energía. Esta situación rara vez ocurre. (Es equivalente a una persona que tiene cáncer, o del tipo que no se puede curar en una etapa avanzada )
c. Excepción es la excepción utilizada por nuestros programadores La clase principal de la clase
d. Exception tiene una subclase llamada RuntimeException, que deriva muchas de nuestras clases de excepción comunes NullPointerException, IndexOutOfBoundsException , etc.
La especificación del lenguaje Java llama a todas las excepciones derivadas de la clase Error o la clase RuntimeException como excepciones verificadas y todas las demás excepciones como excepciones no verificadas.
Si hay una excepción marcada en el código, debe procesarse explícitamente. Si no se procesa, la compilación fallará.
Y el método que hemos dado anteriormente. Es 2.3 y 2.4 , usando la palabra clave throw o la palabra clave throws para el procesamiento . .
4. Clase de excepción personalizada.
Ya existen clases de excepción muy ricas en la biblioteca de Java, pero en escenarios reales, es posible que deseemos crear una clase de excepción que cumpla con nuestros requisitos, es decir, una clase de excepción personalizada. Hereda de la clase Exception.
Tomemos un ejemplo de simulando el inicio de sesión del usuario It:
en la implementación de la función de inicio de sesión del usuario, el usuario puede ingresar el nombre de usuario incorrecto o ingresar la contraseña incorrecta.En este momento, cuando lo procesamos, tenemos que lanzar dos excepciones, a saber, la entrada del nombre de usuario excepción de error y la excepción de entrada de contraseña.Excepción de error para recordar a los clientes.
Excepción de entrada de nombre de usuario personalizado:
public class UserException extends RuntimeException{
public UserException(String message) {
super(message);
}
}
Excepción de entrada de contraseña personalizada:
public class PasswordException extends Exception{
public PasswordException(String message) {
super(message);
}
}
Para la implementación específica, demos un código completo:
import java.util.Scanner;
public class Login {
String name="admin";
String password="123456";
public boolean loginInfo(String n,String p){
if (!name.equals(n)){
//如果输入的用户名和我们所给的不一样,会抛异常
throw new UserException("用户名输入有误");
}
if (!password.equals(p)){
//如果输入的密码和我们所给的不一样,会抛异常
throw new PasswordException("密码输入有误");
}
return true;
}
public static void main(String[] args) {
Scanner sc=new Scanner(System.in);
String s1=sc.next();
String s2=sc.next();
Login login=new Login();
login.loginInfo(s1,s2);
System.out.println("login ok");
sc.close();
}
}