Resumen de aprendizaje de Java: 18

Reconocer anomalías

Una excepción es un flujo de instrucciones en un programa que hace que el programa se interrumpa.
Ejemplo: se produce una excepción

package com.study.Demo;

public class Test1 {
    public static void main(String args[]){
        System.out.println("1.除法计算开始");
        System.out.println("2.除法计算："+(10/0));	//此处产生异常
        //产生异常并且没有正确处理之后，异常之后的语句将不再执行
        System.out.println("3.除法计算结束");
    }
}
//结果
//1.除法计算开始
//Exception in thread "main" java.lang.ArithmeticException: / by zero
//	at com.study.Demo.Test1.main(Test1.java:6)

Para permitir que el programa se ejecute normalmente después de que ocurra una excepción, se debe introducir una declaración de manejo de excepción para mejorar la escritura del código.

Manejar excepciones

Java proporciona tres palabras clave principales para el manejo de excepciones: try, catch y finalmente.

Formato:

try{
//有可能出现异常的语句
}[catch(异常类型 对象){
	//异常处理;
}catch(异常类型 对象){
	//异常处理;
}catch(异常类型 对象){
	//异常处理;
}...][finally{
	;不管是否出现异常，都统一执行的代码
}]

Nota: Se puede omitir el último bloque. Si omite el último bloque y no escribe, el programa continuará ejecutándose después de que el bloque catch () haya terminado de ejecutarse.
Ejemplo: formato de manejo de excepciones de aplicación

package com.study.Demo;

public class Test2 {
    public static void main(String args[]){
        System.out.println("1.除法计算开始");
        try {
            System.out.println("2.除法计算："+(10/0));
            //异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("666");
        }catch (ArithmeticException e){	//处理算术异常
            System.out.println("***出现异常***");
        }
        System.out.println("3.除法计算结束");
    }
}
//结果
//1.除法计算开始
//***出现异常***
//3.除法计算结束

Ejemplo: salida de información completa de anormalidad

package com.study.Demo;

public class Test2 {
    public static void main(String args[]){
        System.out.println("1.除法计算开始");
        try {
            System.out.println("2.除法计算："+(10/0));   //此处产生异常
            //异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("666");
        }catch (ArithmeticException e){ //处理算术异常
            e.printStackTrace();    //输出异常的完整信息
        }
        System.out.println("3.除法计算结束");
    }
}
//结果
//1.除法计算开始
//3.除法计算结束
//java.lang.ArithmeticException: / by zero
//	at com.study.Demo.Test2.main(Test2.java:7)

Ejemplo: usar finalmente

package com.study.Demo;

public class Test2 {
    public static void main(String args[]){
        System.out.println("1.除法计算开始");
        try {
            int x=Integer.parseInt(args[0]);    //接收参数并且转型
            int y=Integer.parseInt(args[1]);    //接收参数并且转型
            System.out.println("2.除法计算："+(x/y));   //此处产生异常
            //异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("666");
        }catch (ArithmeticException e){ //处理算术异常
            e.printStackTrace();    //输出异常的完整信息
        }finally {
            System.out.println("不管是否出现异常我都执行！");
        }
        System.out.println("3.除法计算结束");
    }
}
//结果
//1.除法计算开始
//不管是否出现异常我都执行！
//Exception in thread "main" java.lang.ArrayIndexOutOfBoundsException: //Index 0 out of bounds for length 0
//	at com.study.Demo.Test2.main(Test2.java:7)

Dado que el programa anterior solo maneja excepciones aritméticas (catch (ArithmeticException e)), cuando ocurren otras excepciones, el programa aún no puede manejarlas e interrumpirá la ejecución.

Ejemplo: Agregar múltiples capturas para el manejo de excepciones

package com.study.Demo;

public class Test2 {
    public static void main(String args[]){
        System.out.println("1.除法计算开始");
        try {
            int x=Integer.parseInt(args[0]);    //接收参数并且转型
            int y=Integer.parseInt(args[1]);    //接收参数并且转型
            System.out.println("2.除法计算："+(x/y));   //此处产生异常
            //异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("666");
        }catch (ArithmeticException e){ //处理算术异常
            e.printStackTrace();    //输出异常的完整信息
        }catch (NumberFormatException e){
            e.printStackTrace();
        }catch (ArrayIndexOutOfBoundsException e){
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出现异常我都执行！");
        }
        System.out.println("3.除法计算结束");
    }
}
//结果
//1.除法计算开始
//不管是否出现异常我都执行！
//3.除法计算结束
//java.lang.ArrayIndexOutOfBoundsException: Index 0 out of bounds for length 0
//	at com.study.Demo.Test2.main(Test2.java:7)

Flujo de procesamiento anormal

A través de estas dos clases de excepción, puede encontrar que la clase heredada más alta de todos los tipos de excepción es Throwable, y hay dos subclases en Throwable.
Error: se refiere al error JVM, el programa no se ejecuta en este momento y no se puede manejar;
Excepción: se refiere a la excepción generada durante la operación del programa, el usuario puede usar el formato de manejo de excepciones para manejar.

Ejemplo: use Exception para manejar excepciones

package com.study.Demo;

public class Test2 {
    public static void main(String args[]){
        System.out.println("1.除法计算开始");
        try {
            int x=Integer.parseInt(args[0]);    //接收参数并且转型
            int y=Integer.parseInt(args[1]);    //接收参数并且转型
            System.out.println("2.除法计算："+(x/y));   //此处产生异常
            //异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("666");
        }catch (Exception e) {   //处理所有的异常类型
            e.printStackTrace();
        } finally {
            System.out.println("不管是否出现异常我都执行！");
        }
        System.out.println("3.除法计算结束");
    }
}
//结果
//1.除法计算开始
//不管是否出现异常我都执行！
//3.除法计算结束
//java.lang.ArrayIndexOutOfBoundsException: Index 0 out of bounds for length 0
//	at com.study.Demo.Test2.main(Test2.java:7)

La excepción del programa anterior es manejada por Exception, de modo que no importa qué tipo de problema de excepción ocurra en el programa, el programa puede ser capturado y procesado.

Nota: Cuando se manejan múltiples excepciones, las excepciones con un rango de captura pequeño se deben manejar antes que las excepciones con un rango de captura grande.
Según la relación de herencia, ArithmeticException debe ser una subclase de Exception, por lo que al escribir el manejo de excepciones, el procesamiento de Exception debe escribirse después del procesamiento de ArithmeticException, de lo contrario habrá un error de sintaxis.
Ejemplo: orden de captura de excepción incorrecto

package com.study.Demo;

public class Test2 {
    public static void main(String args[]){
        System.out.println("1.除法计算开始");
        try {
            int x=Integer.parseInt(args[0]);    //接收参数并且转型
            int y=Integer.parseInt(args[1]);    //接收参数并且转型
            System.out.println("2.除法计算："+(x/y));   //此处产生异常
            //异常产生之后的语句将不再执行，此处在try中产生异常，所以下面的输出不会执行
            System.out.println("666");
        }catch (Exception e){   //已经处理完所有的异常类型
            e.printStackTrace();
        }
        catch (ArithmeticException e){ //此处无法处理，Exception已处理完
            e.printStackTrace();    //输出异常的完整信息
        } finally {
            System.out.println("不管是否出现异常我都执行！");
        }
        System.out.println("3.除法计算结束");
    }
}
//结果
//Error:(15, 9) java: 已捕获到异常错误java.lang.ArithmeticException