Notas de estudio de Java (12) Capítulo 12 - Excepción - Excepción

12.1 Problemas prácticos, soluciones, introducción de excepción

• Mire un problema real y una pieza de código

Ejecute el siguiente código para ver cuál es el problema -> conduce a la excepción y al mecanismo de manejo de excepciones Exception01.java

public static void main(String[] args) {
    
    
int num1 = 10;
int num2 = 0;
int res = num1 / num2;
System.out.println("程序继续运行....");
}

• Solución: captura de excepciones

  
  Capture la excepción para asegurarse de que el programa pueda continuar ejecutándose.

El bloque de código -> seleccionar -> tecla de acceso directo ctrl + alt + t -> seleccionar try-catch
e.getMessage() también puede generar información de excepción

public class Exception01 {
    
    
    public static void main(String[] args)  {
    
    
        int num1 = 10;
        int num2 = 0;//Scanner();

        //解读
        //1. num1 / num2 => 10 / 0
        //2. 当执行到 num1 / num2 因为 num2 = 0, 程序就会出现(抛出)异常 ArithmeticException
        //3. 当抛出异常后，程序就退出，崩溃了 , 下面的代码就不再执行
        //4. 大家想想这样的程序好吗? 不好，不应该出现了一个不算致命的问题，就导致整个系统崩溃
        //5. java 设计者，提供了一个叫 异常处理机制来解决该问题
//        int res = num1 / num2;
        //如果程序员，认为一段代码可能出现异常/问题，可以使用try-catch异常处理机制来解决
        //从而保证程序的健壮性
        //将该代码块->选中->快捷键 ctrl + alt + t -> 选中 try-catch
        //6. 如果进行异常处理，那么即使出现了异常，程序可以继续执行
        try {
    
    
            int res = num1 / num2;
        } catch (Exception e) {
    
    
            //e.printStackTrace();
            System.out.println("出现异常的原因=" + e.getMessage());//输出异常信息
        }

        System.out.println("程序继续运行....");

    }
}

• Introducción a la excepción

concepto basico:

En el lenguaje Java, una situación anormal que ocurre durante la ejecución del programa se denomina "anormal". (Los errores de sintaxis y los errores de lógica durante el desarrollo no son excepciones)

Los eventos anormales que ocurren durante la ejecución se pueden dividir en dos categorías

1. Error (Error): Un problema grave que la máquina virtual Java no puede resolver. Tales como: errores internos del sistema JVM, agotamiento de recursos y otras situaciones graves. Por ejemplo: StackOverflowError [desbordamiento de pila] y OOM (memoria insuficiente), Error es un error grave y el programa fallará.
2. Excepción: Otros problemas generales causados ​​por errores de programación o factores externos accidentales pueden manejarse con códigos específicos. Por ejemplo, acceso de puntero nulo, intento de leer un archivo que no existe, interrupción de la conexión de red, etc., la excepción se divide en dos categorías: excepción de tiempo de ejecución [excepción que ocurre cuando el programa se está ejecutando] y excepción de tiempo de compilación [cuando programación, el compilador comprueba la excepción].

12.2 Descripción general del diagrama del sistema anormal

12.2.1 Diagrama del sistema anormal

12.2.2 Resumen de la jerarquía de excepciones

1. Hay dos tipos de excepciones, excepciones de tiempo de ejecución y excepciones de tiempo de compilación.
2. El compilador no puede detectar la excepción de tiempo de ejecución. Generalmente, se refiere a un error lógico durante la programación, que es una excepción que los programadores deben evitar. La clase java.lang.RuntimeException y sus subclases son excepciones de tiempo de ejecución
3. Para las excepciones de tiempo de ejecución, no es necesario manejarlas, porque tales excepciones son muy comunes y, si se procesan por completo, pueden tener un impacto en la legibilidad y la eficiencia operativa del programa.
4. Las excepciones en tiempo de compilación son excepciones que debe manejar el compilador.

12.3 Excepciones comunes de tiempo de ejecución, ejemplos

• Las excepciones comunes de tiempo de ejecución incluyen

1. NullPointerException excepción de puntero nulo
2. ArithmeticException Excepción de operación matemática
3. ArrayIndexOutOfBoundsException Array subíndice fuera de límites excepción
4. Excepción de conversión de tipo ClassCastException
5. NumberFormatException el formato del número no es la excepción correcta []

• Ejemplos de excepciones de tiempo de ejecución comunes

1. NullPointerException NullPointerException_.java
   Cuando la aplicación intenta usar null donde se requiere un objeto, es decir, el objeto se usa antes de crearlo. Lance esta excepción, consulte la demostración del caso.

public class NullPointerException_ {
    
    
    public static void main(String[] args) {
    
    
        String name = null;
        System.out.println(name.length());
    }
}

2. ArithmeticException Excepción de operación matemática ArithmeticException_.java
   Esta excepción se lanza cuando ocurre una condición de operación anormal. Por ejemplo, cuando un número entero se "divide por cero", el código en 12.1 de este artículo
3. ArrayIndexOutOfBoundsException Excepción fuera de los límites del subíndice de matriz
   Una excepción lanzada cuando se usa un índice ilegal para acceder a una matriz. Un índice es un índice ilegal si es negativo o mayor o igual al tamaño de la matriz

public class ArrayIndexOutOfBoundsException_ {
    
    
    public static void main(String[] args) {
    
    
        int[] arr = {
    
    1,2,4};
        for (int i = 0; i <= arr.length; i++) {
    
     // <=不对
            System.out.println(arr[i]);
        }
    }
}

4. ClassCastException Excepción de conversión de tipos Se lanza
   cuando se intenta convertir un objeto a una subclase que no es una instancia. Por ejemplo, el siguiente código generará una ClassCastException

public class ClassCastException_ {
    
    
    public static void main(String[] args) {
    
    
        A b = new B(); //向上转型,OK
        B b2 = (B)b;//向下转型，这里是OK，因为b本来就指向B
        C c2 = (C)b;//b指向的对象转成C，不行，B和C没啥关系，这里抛出ClassCastException
    }
}
class A {
    
    }
class B extends A {
    
    }
class C extends A {
    
    }

5. NumberFormatException Formato de número incorrecto Excepción lanzada
   cuando la aplicación intenta convertir una cadena a un tipo numérico, pero la cadena no se puede convertir al formato adecuado => Usando excepciones, podemos asegurarnos de que la entrada sea un número que satisfaga la condición.

public class NumberFormatException_ {
    
    
    public static void main(String[] args) {
    
    
        String num = "1234"; //这是ok的
        String name = "Java教育";
        //将String 转成 int
        int num1 = Integer.parseInt(num);//这是ok的
        int name1 = Integer.parseInt(name);//抛出NumberFormatException
        System.out.println(num);//1234
    }
}

12.4 Excepción de compilación

• Introducción
  Las excepciones de compilación se refieren a las excepciones que se deben manejar durante la compilación, de lo contrario, el código no se puede compilar.

• Excepciones comunes de compilación

  SQLException //Al operar la base de datos, puede ocurrir una excepción en la tabla de consulta
  IOException//Al operar un archivo, ocurre una excepción
  FileNotFoundException//Al operar un archivo que no existe, ocurre una excepción
  ClassNotFoundException//Al cargar una clase, pero la clase no existe, ocurre una excepción
  EOFException//archivo de operación, hasta el final del archivo, ocurre una excepción
  excepción de argumento ilegal//excepción de parámetro

12.5 Ejercicios de aula anormales

12.6 Manejo de excepciones

• 1. Introducción básica

  El manejo de excepciones es la forma en que se maneja una excepción cuando ocurre una excepción.

• 2. La forma de manejo de excepciones

  (1) los programadores try-catch-finally
  capturan la excepción en el código y la manejan por sí mismos
  (2) lanza
  la excepción y se la pasa a la persona que llama (método) para que la procese. El procesador superior es la JVM

• 3. Diagrama esquemático

Diagrama esquemático del mecanismo de procesamiento try-catch-finally Diagrama

del mecanismo de procesamiento de lanzamientos

12.7 manejo de excepciones try-catch

resumen de la secuencia de ejecución try-catch-finally

1. Si no hay excepción, ejecute todas las declaraciones en el bloque try y no ejecute las declaraciones en el bloque catch.Si finalmente hay, debe ejecutar las declaraciones en finalmente.
2. Si ocurre una excepción, después de que ocurra la excepción en el bloque de prueba, las declaraciones restantes en el bloque de prueba no se ejecutarán. Se ejecutará la declaración en el bloque catch. Si finalmente hay, ¡la declaración enfinalmente debe ejecutarse por fin!

12.7.1 Descripción del manejo de excepciones en modo try-catch

1. Java proporciona bloques de prueba y captura para manejar excepciones. El bloque try se usa para contener código que puede salir mal. El bloque catch se usa para manejar las excepciones que ocurren en el bloque try. Puede tener tantos bloques try...catch en su programa como desee.
2. Gramática básica
   try { //Código sospechoso //Genera el objeto de excepción correspondiente a partir de la excepción y pásalo al bloque catch} catch (excepción) { //Procesando la excepción} //Si no hay finalmente, la sintaxis puede pasar
   
   
   
   
   

12.7.2 Manejo de excepciones en modo try-catch - Notas

TryCatchDetail.java

1. Si ocurre una excepción, el código detrás de la excepción no se ejecutará y entrará directamente en el bloque catch.
2. Si la excepción no ocurre, el bloque de código de prueba se ejecutará secuencialmente y no ingresará a la captura.
3. Si desea ejecutar una determinada pieza de código independientemente de si se produce una excepción (como cerrar la conexión, liberar recursos, etc.), use el siguiente código: finalmente {}
4. Puede haber varias declaraciones de captura para capturar diferentes excepciones (para diferentes procesos comerciales), lo que requiere que la excepción de la clase principal sea seguida por la excepción de la subclase, por ejemplo (la excepción es seguida por NullPointerException), y si ocurre una excepción, solo coincidirá Una captura, demostración de caso
5. Se puede usar junto con try-finally. Este uso es equivalente a no detectar excepciones, por lo que el programa se bloqueará/saldrá directamente . El escenario de la aplicación es ejecutar un fragmento de código, independientemente de que ocurra una excepción, se debe ejecutar una cierta lógica de negocios.

Punto 1-3 código de detalle:

public class TryCatchDetail {
    
    
    public static void main(String[] args) {
    
    
        //ctrl + atl + t
        try {
    
    
            String str = "南昌大学";
            int a = Integer.parseInt(str);
            System.out.println("数字：" + a);
        } catch (NumberFormatException e) {
    
    
            System.out.println("异常信息=" + e.getMessage());
        } finally {
    
    
            System.out.println("finally代码块被执行...");
        }
        System.out.println("程序继续...");
    }
}

Código de detalle del punto 4:

public class TryCatchDetail02 {
    
    
    public static void main(String[] args) {
    
    
        try {
    
    
            Person person = new Person();
            person = null;
            System.out.println(person.getName());//NullPointerException
            int n1 = 10;
            int n2 = 0;
            int res = n1 / n2;//ArithmeticException
        } catch (NullPointerException e) {
    
    
            System.out.println("空指针异常=" + e.getMessage());
        } catch (ArithmeticException e) {
    
    
            System.out.println("算术异常=" + e.getMessage());
        } catch (Exception e) {
    
    
            System.out.println(e.getMessage());
        } finally {
    
    
        }
    }
}
class Person {
    
    
    private String name = "jack";
    public String getName() {
    
    
        return name;
    }
}

Código de detalle del punto 5:

public class TryCatchDetail03 {
    
    
    public static void main(String[] args) {
    
    
        try{
    
    
            int n1 = 10;
            int n2 = 0;
            System.out.println(n1 / n2);
        }finally {
    
    
            System.out.println("执行了finally.."); //程序直接退出
        }
        System.out.println("程序继续执行..");//这一句不会执行了
    }
}

12.7.3 Ejercicios de clase de manejo de excepciones

1. Pregunta 1 TryCatchExercise01.java
   
2. Pregunta 2 TryCatchExercise02.java
   
3. Pregunta 3 TryCatchExercise03.java
   
4. Si el usuario ingresa algo que no sea un número entero, pídale que ingrese repetidamente hasta que ingrese un número entero

import java.util.Scanner;
public class TryCatchExercise04 {
    
    
    public static void main(String[] args) {
    
    
        //如果用户输入的不是一个整数，就提示他反复输入，直到输入一个整数为止
        //思路
        //1. 创建Scanner对象
        //2. 使用无限循环，去接收一个输入
        //3. 然后将该输入的值，转成一个int
        //4. 如果在转换时，抛出异常，说明输入的内容不是一个可以转成int的内容
        //5. 如果没有抛出异常，则break 该循环
        Scanner scanner = new Scanner(System.in);
        int num = 0;
        String inputStr = "";
        while (true) {
    
    
            System.out.println("请输入一个整数:"); //
            inputStr = scanner.next();
            try {
    
    
                num = Integer.parseInt(inputStr); //这里是可能抛出异常
                break;
            } catch (NumberFormatException e) {
    
    
                System.out.println("你输入的不是一个整数:");
            }
        }
        System.out.println("你输入的值是=" + num);
    }
}

12.8 lanza el manejo de excepciones

• 1. Introducción básica

1. Si un método (cuando se ejecuta la declaración en él) puede generar algún tipo de excepción, pero no está seguro de cómo manejar esta excepción, este método debe declarar explícitamente que se lanza la excepción, lo que indica que el método no manejará estas excepciones. , pero por el método La persona que llama al método es responsable del procesamiento.
2. En la declaración del método, la declaración throws se puede usar para declarar la lista de excepciones lanzadas.El tipo de excepción detrás de throws puede ser el tipo de excepción generado en el método o su clase principal.

• 2. Caso de inicio rápido
  public static void readFile(String file) throws FileNotFoundException { La operación de leer un archivo puede generar una excepción de tipo FileNotFoundException FilelnputStream fis = new FilelnputStream(“d://aa.txt”); }
  
  
  

import java.io.FileInputStream;
import java.io.FileNotFoundException;
public class Throws01 {
    
    
    public static void main(String[] args) {
    
    
    }
    public void f2() throws FileNotFoundException,NullPointerException,ArithmeticException {
    
    
        //创建了一个文件流对象
        //解读:
        //1. 这里的异常是一个FileNotFoundException 编译异常
        //2. 使用前面讲过的 try-catch-finally
        //3. 使用throws ,抛出异常, 让调用f2方法的调用者(方法)处理
        //4. throws后面的异常类型可以是方法中产生的异常类型，也可以是它的父类Exception
        //5. throws 关键字后也可以是 异常列表, 即可以抛出多个异常
        FileInputStream fis = new FileInputStream("d://aa.txt");
    }
}

• 3. Precauciones y detalles de uso

1. Para las excepciones de compilación, debe manejarse en el programa, como try-catch o throws
2. Para las excepciones de tiempo de ejecución, si no hay procesamiento en el programa, el valor predeterminado es manejarlas en forma de lanzamientos [ejemplo]
3. Cuando una subclase reescribe el método de la clase principal, las reglas para lanzar excepciones: el método reescrito por la subclase, el tipo de excepción lanzada es la misma que la lanzada por la clase principal o el tipo de excepción lanzada por la clase principal. subtipo de clase principal de [ejemplo]
4. En el proceso de lanzamientos, si hay un método try-catch, es equivalente a manejar excepciones, por lo que no necesita lanzar

import java.io.FileInputStream;
import java.io.FileNotFoundException;

public class ThrowsDetail {
    
    
    public static void main(String[] args) {
    
    
        f2();
    }
    public static void f2() /*throws ArithmeticException*/ {
    
    
        //1.对于编译异常，程序中必须处理，比如 try-catch 或者 throws
        //2.对于运行时异常，程序中如果没有处理，默认就是throws的方式处理
        int n1 = 10;
        int n2 = 0;
        double res = n1 / n2;
    }

    public static void f1() throws FileNotFoundException {
    
    
        //这里大家思考问题 调用f3() 报错
        //解读
        //1. 因为f3() 方法抛出的是一个编译异常
        //2. 即这时，就要f1() 必须处理这个编译异常
        //3. 在f1() 中，要么 try-catch-finally ,或者继续throws 这个编译异常
        f3(); // 抛出异常
    }
    public static void f3() throws FileNotFoundException {
    
    
        FileInputStream fis = new FileInputStream("d://aa.txt");
    }

    public static void f4() {
    
    
        //解读:
        //1. 在f4()中调用方法f5() 是OK
        //2. 原因是f5() 抛出的是运行异常
        //3. 而java中，并不要求程序员显示处理,因为有默认处理机制
        f5();
    }
    public static void f5() throws ArithmeticException {
    
    

    }
}

class Father {
    
     //父类
    public void method() throws RuntimeException {
    
    
    }
}
class Son extends Father {
    
    //子类
    //3. 子类重写父类的方法时，对抛出异常的规定:子类重写的方法，
    //   所抛出的异常类型要么和父类抛出的异常一致，要么为父类抛出的异常类型的子类型
    //4. 在throws 过程中，如果有方法 try-catch , 就相当于处理异常，就可以不必throws
    @Override
    public void method() throws ArithmeticException {
    
    
    }
}

12.9 Lanzamiento manual de excepciones throw

• 1. Introducción básica

Al escribir un programa, debemos considerar la situación en la que el programa tiene problemas. Por ejemplo, al definir un método, el método debe aceptar parámetros. Luego, cuando el método de llamada usa los parámetros recibidos, primero es necesario hacer un juicio legal sobre los datos de parámetros.Si los datos no son legales, debe decirle a la persona que llama que pase los datos legales. En este momento, se debe lanzar una excepción para informar a la persona que llama.

Además de ser generado y lanzado automáticamente por el sistema cuando ocurre una excepción durante la ejecución del programa, el objeto de clase de excepción de Java también puede crearse y lanzarse manualmente según sea necesario.

En java, se proporciona una palabra clave throw, que se utiliza para lanzar un objeto de excepción especificado. No se procesa en el método actual y se lanza a la persona que llama para su procesamiento.
　　
　 Hay dos formas de crear y lanzar objetos de excepción:
(1) JVM crea y lanza
(2) manualmente nuevos y luego los lanza por lanzamiento.

Lanzable: solo si el objeto es una instancia de esta clase (o una de sus subclases) puede ser lanzado por la máquina virtual Java o la declaración de lanzamiento de Java.

De manera similar, solo esta clase o una de sus subclases puede ser el tipo de parámetro en una cláusula catch.

Lanzamiento manual de objetos de excepción:
(1) Primero, genere objetos de clase de excepción y luego implemente la operación de lanzamiento a través de la instrucción throw (enviada al entorno de tiempo de ejecución de Java)

IOException e = new IOException();
throw e；

(2) Una excepción que se puede lanzar debe ser una instancia de Throwable o sus subclases. La siguiente declaración generará un error de sintaxis cuando se compile:

throw new String("want to throw");

• Dos, throw lanza unos pasos de implementación de excepción

  (1) Cree un objeto de excepción. Encapsule alguna información rápida (la información puede escribirla usted mismo)
  (2) El objeto de excepción debe informarse a la persona que llama. Esto se hace con la palabra clave throw. lanzar el objeto de excepción.

Formato de uso: lanzar un nuevo nombre de clase de excepción ("el motivo de la excepción (edítelo usted mismo)");

• 3. La función de la palabra clave throw
  se usa en el método para lanzar un objeto de excepción, pasar el objeto de excepción a la persona que llama y finalizar la ejecución del método actual. Nota: (1) La palabra clave throw debe escribirse dentro del método (2) El nuevo objeto detrás de la palabra clave throw debe ser Exception o un objeto de subclase de Exception (3) La palabra clave throw arroja el objeto de excepción especificado, debemos manejar esta excepción objeto (4) El objeto creado después de la palabra clave throw es RuntimeException o un objeto de subclase de RuntimeException, no podemos manejarlo y se entregará a la JVM de forma predeterminada (imprime el objeto de excepción, interrumpe el programa) (5) Creado después de la palabra clave throw Es una excepción de compilación (informando un error al escribir código), debemos lidiar con esta excepción, ya sea throws, o try... catch
  
  
  
  
  
  

• Cuarto, la diferencia entre tirar y tirar.

Pregunta de la entrevista: ¿Cuál es la diferencia entre throw y throws?
(1) throw se usa para lanzar manualmente un objeto de excepción, que es una declaración ejecutable
(2) throws: en la firma del método, declara qué excepciones puede lanzar el método y deja que la persona que llama maneje estas excepciones.

12.10 Excepciones personalizadas

• 1. Conceptos básicos
  Cuando ocurren algunos "errores" en el programa, pero la información del error no se describe en la subclase Throwable, puede diseñar su propia clase de excepción para describir la información del error.

• Dos, los pasos de la excepción personalizada.

1. Clase de definición: el nombre de la clase de excepción personalizada (escrito por el programador) hereda Exception o RuntimeException
2. Si hereda Exception, es una excepción de compilación
3. Si hereda RuntimeException, es una excepción en ejecución (en términos generales, hereda RuntimeException)

• 3. Ejemplo de aplicación de excepción personalizada CustomException.java
  Cuando recibimos la edad del objeto Person, se requiere que el rango esté entre 18 y 120; de lo contrario, se lanza una excepción personalizada (requerida para heredar RuntimeException) y se da un mensaje de aviso.

public class CustomException {
    
    
    public static void main(String[] args) /*throws AgeException*/ {
    
    

        int age = 180;
        //要求范围在 18 – 120 之间，否则抛出一个自定义异常
        if(!(age >= 18 && age <= 120)) {
    
    
            //这里我们可以通过构造器，设置信息
            throw new AgeException("年龄需要在 18~120之间");
        }
        System.out.println("你的年龄范围正确.");
    }
}
//自定义一个异常
//解读
//1. 一般情况下，我们自定义异常是继承 RuntimeException
//2. 即把自定义异常做成 运行时异常，好处是，我们可以使用默认的处理机制
//3. 即比较方便
class AgeException extends RuntimeException {
    
    
    public AgeException(String message) {
    
    //构造器
        super(message);
    }
}

12.11 Diferencia entre lanzamiento y lanzamientos

• lista
  
• Pregunta de prueba: ¿qué genera la siguiente salida de prueba? ThrowException.java 2 min
  

12.12 Tarea para este capítulo

1. Pregunta de programación Homework01.java
   a) Escriba el programa de aplicación EcmDef.java, reciba dos parámetros (enteros) de la línea de comando y calcule la división de los dos números.
   b) Para calcular la división de dos números, se requiere usar el método cal(int n1, int n2)
   c) Para manejar excepciones por formato de datos incorrecto (NumberformatException), falta de parámetros de línea de comando (ArraylndexOutOfBoundsException) y división por 0 (Excepción Aritmética).

Nota: este código usa el artículo anterior https://blog.csdn.net/m0_50736744/article/details/121450090?spm=1001.2014.3001.5501 en 10.2 Comprensión de la sintaxis del método principal: comprensión profunda de los argumentos del método principal

public class Homework01 {
    
    
    public static void main(String[] args) {
    
    
    
        try {
    
    
            //先验证输入的参数的个数是否正确 两个参数
            if(args.length != 2) {
    
    
                throw new ArrayIndexOutOfBoundsException("参数个数不对");
            }

            //先把接收到的参数，转成整数
            int n1 = Integer.parseInt(args[0]);
            int n2 = Integer.parseInt(args[1]);

            double res = cal(n1, n2);//该方法可能抛出ArithmeticException
            System.out.println("计算结果是=" + res);

        } catch (ArrayIndexOutOfBoundsException e) {
    
    
            System.out.println(e.getMessage());
        } catch (NumberFormatException e) {
    
    
            System.out.println("参数格式不正确，需要输入整数");
        } catch (ArithmeticException e) {
    
    
            System.out.println("出现了除0的异常");
        }
    }
    //编写cal方法，就是两个数的商
    public static double cal(int n1, int n2) {
    
    
        return n1 / n2;
    }
}

2. Pregunta 2, dígame si ocurrirá una excepción en el siguiente código y, de ser así, ¿qué tipo de excepción es? Si no, ¿cuál es el resultado impreso?

public class Homework02 {
    
    
    public static void main(String[] args) {
    
    
		
        if(args[4].equals("john")){
    
      //可能发生ArrayIndexOutOfBoundsException，
                                 //因为一开始args.length = 0,或者一开始传的值不5个
            System.out.println("AA");
        }else{
    
    
            System.out.println("BB");
        }
        Object o= args[2]; //String->Object ，向上转型
        Integer i = (Integer)o; //错误，这里一定会发生 ClassCastException,因为上边是字符串赋给了o，这里把字符串o转换为整数不对
    }
}

3. Pregunta 3
   
4. Pregunta 4