Tabla de contenido

Las dos funciones de las excepciones son:

Manejo de excepciones:

1. Procesamiento predeterminado de JVM

2. Atrapa la excepción tú mismo

3. Procesamiento de lanzamiento

Excepción personalizada:

Ventajas de las excepciones:

Resumir:

Prefacio:

En el artículo anterior, presentamos el marco de todo el sistema de excepciones en detalle. En este artículo, presentaremos Excepciones para usted . Explicaremos su función y cómo detectarlo. ¡ Este artículo es muy importante! ! Es una habilidad muy útil al construir el backend e interactuar con el frontend, por lo que incluso si no leemos este artículo, ¡debemos comprender activamente el contenido relevante nosotros mismos! !

Excepciones:

En Java, las excepciones (Exceptions) también son un mecanismo para manejar errores o condiciones anormales durante la ejecución del programa . Las excepciones están representadas por clases en Java, que se denominan clases de excepción (clases de excepción).

El mecanismo de excepción en Java se basa en el principio de " lanzar y atrapar ". Cuando ocurre una excepción en el programa, la excepción se crea y se lanza (lanzar), y luego se detecta (captura) en otra parte del código, y se ejecuta la lógica de procesamiento correspondiente.

Las clases de excepción en Java se derivan de la clase `java.lang.Exception`. Las clases de excepción se dividen en dos categorías: Excepciones comprobadas y Excepciones no comprobadas.

1. Verifique las excepciones:

Las excepciones marcadas se refieren a situaciones específicas que pueden surgir en el código que deben manejarse explícitamente.
Las excepciones verificadas deben declararse en la declaración del método o capturarse en un bloque try-catch dentro del cuerpo del método.
Por ejemplo: IOException, FileNotFoundException, etc.

2. Excepción no verificada:

Las excepciones no verificadas son excepciones que pueden ocurrir mientras se ejecuta el programa.
Las excepciones no verificadas generalmente son causadas por errores del programa, como una matriz fuera de los límites, errores de división por cero, etc.
Las excepciones no verificadas no necesitan ser capturadas en la declaración del método o en el cuerpo del método, pero pueden ser capturadas y manejadas opcionalmente.
Por ejemplo: NullPointerException, ArithmeticException, etc.

Java proporciona varias palabras clave y declaraciones para manejar excepciones, que incluyen:

La instrucción try-catch se usa para capturar y manejar excepciones.
La palabra clave throws se usa para declarar los tipos de excepciones que se pueden lanzar.
El bloque finalmente se usa para definir el código que debe ejecutarse, ya sea que ocurra una excepción o no.
La palabra clave throw se usa para lanzar excepciones manualmente.

Mediante el manejo adecuado de las excepciones, se puede mejorar la solidez y la confiabilidad de los programas Java para garantizar que los programas aún puedan ejecutarse normalmente en condiciones anormales.

Las dos funciones de las excepciones son:

1. La excepción es la información de referencia clave utilizada para consultar errores.

Suponga que escribe un programa que maneja los inicios de sesión de los usuarios, incluida una función para la autenticación de usuarios. Si el nombre de usuario proporcionado por el usuario no existe, puede lanzar una excepción "UserNotFoundException". Esta excepción contendrá información clave sobre el error, como el nombre de usuario, para facilitar la depuración y corrección de errores al manejar la excepción.

Por ejemplo:

public class UserLogin {
  public void validateUser(String username, String password) throws UserNotFoundException {
    // 在数据库中查找用户
    if (!userExists(username)) {
      throw new UserNotFoundException("用户名不存在：" + username);
    }
    // 进行密码验证等其他操作
    // ...
  }
  
  private boolean userExists(String username) {
    // 查询数据库，判断用户是否存在
    // ...
  }
  
  // 其他代码
}

En el ejemplo anterior, si el nombre de usuario proporcionado por el usuario no existe en la base de datos, el programa lanzará una "UserNotFoundException" y pasará una cadena que contiene el mensaje de error. Al ver la información de la excepción, puede rastrear dónde ocurrió el error y corregirlo si es necesario, como verificar la lógica de consulta de la base de datos, etc. Los mensajes de excepción son muy útiles para los desarrolladores porque brindan pistas importantes sobre dónde y por qué ocurrió un error. Y solíamos necesitar usar la impresión para generar manualmente una "contraseña no existe".

Entonces, ¿por qué no optar por imprimir un error?

Esto se debe a que lanzar excepciones es una práctica más flexible y disciplinada. Proporciona un mecanismo de manejo de excepciones unificado, de modo que las personas que llaman pueden capturar y manejar las excepciones según sea necesario, en lugar de simplemente imprimir mensajes de error. Las excepciones también pueden pasar información de error y contexto más detallados, lo cual es conveniente para que la persona que llama realice una lógica de manejo de errores más avanzada. La impresión de mensajes de error, si bien es simple y directa, puede no ser flexible ni escalable para programas complejos y necesidades de manejo de errores. Y después de que se lanza la excepción, el programa dejará de ejecutarse directamente, y nuestro error de impresión de impresión es solo una ejecución normal de una declaración de impresión para el compilador, y aún continuará, y debemos detenerlo manualmente.

2. La excepción se puede usar como un valor de retorno especial dentro del método para informar a la persona que llama sobre el estado de ejecución subyacente.

public class FileProcessor {
    public void processFile(String fileName) throws FileProcessingException {
        try {
            // 打开文件，进行处理
            openFile(fileName);
            // 其他处理逻辑
            // ...
            // 关闭文件
            closeFile();
        } catch (IOException e) {
            // 处理文件操作异常
            throw new FileProcessingException("文件处理发生异常", e);
        }
    }
    
    private void openFile(String fileName) throws IOException {
        // 打开文件的逻辑
        // ...
    }
    
    private void closeFile() throws IOException {
        // 关闭文件的逻辑
        // ...
    }
}

En el ejemplo anterior, el método FileProcessorde la clase processFilese usa para procesar el archivo especificado. Si ocurre una excepción de operación de archivo mientras se procesa el archivo (como que el archivo no se puede abrir, leer o cerrar, etc.), generará una FileProcessingExceptionexcepción y IOExceptionpasará el motivo subyacente a la persona que llama.

De esta manera, la persona que llama puede capturar y manejar la excepción y obtener más información sobre la ejecución subyacente, por ejemplo, si el archivo se abrió y cerró correctamente. Las excepciones proporcionan un mecanismo que permite que la información de error pase de los detalles de implementación de un método a la persona que llama al método para que la persona que llama pueda tomar las medidas adecuadas según sea necesario.

La diferencia entre la excepción como un valor de retorno especial dentro de un método y su información de referencia clave para consultar errores radica principalmente en su propósito y uso . Todos proporcionan información sobre la ejecución subyacente. Cuando se usan como valor de retorno dentro de un método, las excepciones se usan para transmitir el estado de ejecución; cuando se consultan errores, la información de excepción se usa para diagnosticar y depurar código incorrecto.

Manejo de excepciones:

1. Procesamiento predeterminado de JVM

El método de procesamiento predeterminado de la JVM es generar información como el nombre de la excepción, la causa de la excepción y la ubicación donde ocurrió la excepción en la consola. El programa también dejará de ejecutarse en este momento y las siguientes instrucciones no se ejecutarán.

Por ejemplo, ejecute este código directamente:

public class test10 {
    public static void main(String[] args) {
        int[] arr = new int[3];
        System.out.println(arr[4]); // 数组越界异常
    }
}

La consola generará:

2. Atrapa la excepción tú mismo

Nosotros mismos detectamos las excepciones mediante el uso de declaraciones de prueba y captura, declaraciones de excepción personalizadas y estrategias de ejecución después de que ocurren las excepciones.

El formato es:

try{
可能出现异常的代码；
}
catch{
异常的处理代码
}

Propósito: cuando ocurre una excepción en el código, el programa puede continuar ejecutándose. No detendrá el programa directamente como cuando la JVM lo maneja por defecto.

public class test10 {
    public static void main(String[] args) {
        try {
            int result = divide(10, 0); // 调用自定义的除法方法
            System.out.println("结果：" + result);
        } catch (ArithmeticException e) { // 捕获特定类型的异常
            System.out.println("除数不能为零！");
            e.printStackTrace(); // 打印堆栈跟踪
        }
        System.out.println("我可以被执行！");
    }

    public static int divide(int dividend, int divisor) {
        return dividend / divisor; // 可能引发除零异常的除法操作
    }
}

El resultado de la ejecución es:

Hay tres situaciones en las que try detecta excepciones:

catch Cada excepción es capturada y manejada por un bloque diferente : try cada declaración en un bloque que puede generar una excepción tiene un catch bloque correspondiente para capturar y manejar esa excepción. Esto permite que se ejecute la lógica de manejo adecuada en función de diferentes tipos de excepciones.

try {
    // 可能抛出异常的语句1
    // 可能抛出异常的语句2
    // ...
} catch (ExceptionType1 e1) {
    // 处理异常类型1
} catch (ExceptionType2 e2) {
    // 处理异常类型2
} catch (ExceptionType3 e3) {
    // 处理异常类型3
}

Múltiples excepciones son capturadas y manejadas por el mismo catch bloque: Si varias excepciones son subtipos del mismo tipo de excepción, catch pueden ser capturadas y manejadas por el mismo bloque. En este caso, las diferentes excepciones de subtipo se pueden distinguir y manejar a través de las propiedades o métodos del objeto de excepción.

try {
    // 可能抛出异常的语句1
    // 可能抛出异常的语句2
    // ...
} catch (ParentExceptionType e) {
    // 处理多个异常类型
}

La excepción es capturada por el bloque de captura superior: si try un bloque en el bloque catch captura con éxito una excepción y no se lanza ninguna excepción nueva, entonces la excepción se considerará manejada y no se pasará a la siguiente catch pieza.

try {
    // 可能抛出异常的语句1
    // 可能抛出异常的语句2
    // ...
} catch (ExceptionType1 e1) {
    // 处理异常类型1，并不再传递异常
} catch (ExceptionType2 e2) {
    // 处理异常类型2
}

Si la excepción en nuestro tyr no se captura (por ejemplo, se lanza una excepción fuera de los límites de la matriz, pero solo escribimos para juzgar la excepción del puntero nulo, y la excepción en este momento no se captura), entonces ejecutaremos el método de procesamiento predeterminado de la JVM.

Notas sobre la captura de excepciones:

1. Si queremos capturar múltiples excepciones, y hay una relación padre-hijo en estas excepciones, entonces la clase padre debe estar en la parte inferior

De esta manera, las excepciones coincidentes de captura coinciden de arriba a abajo, y las excepciones principales pueden aceptar todas las excepciones de subclase, lo que lleva a que todas las excepciones se acepten cuando van a la excepción de clase principal, mientras que las excepciones de subclase subsiguientes se reciben si no hay una excepción. , la excepción de la clase principal acepta la excepción de la subclase y es posible que no podamos obtener el resultado que queremos, por lo que debemos colocar la excepción de la clase principal al final de la excepción de la subclase.

Si desea capturar todas las excepciones que se pueden generar, puede usar Exceptionla clase como catchparámetro del bloque. Esto captura todas Exceptionlas excepciones derivadas de.

try {
    // 可能抛出异常的语句
} catch (Exception e) {
    // 处理异常
}

Si desea capturar un tipo específico de excepción, puede usar esa clase de excepción o una subclase de ella como catchargumento para el bloque.

try {
    // 可能抛出异常的语句
} catch (ArithmeticException e) {
    // 处理算术异常
} catch (NullPointerException e) {
    // 处理空指针异常
} catch (IOException e) {
    // 处理输入输出异常
}catch (Exception e) {
    // 处理异常
}

Al comprender la relación entre la clase principal y la clase secundaria, se pueden manejar diferentes tipos de excepciones de manera más efectiva y se puede proporcionar un mecanismo de manejo de errores apropiado para el programa.

2. Siempre que se genere una excepción en el intento, el resto del intento se omitirá, por lo que no podemos escribir varias declaraciones de excepción en un intento, lo cual es inútil, solo se ejecutará la primera excepción, y escribimos tantas atrapa, el significado es que para esta única excepción, ¡tenemos que atraparla de manera específica!

public class test10 {
    public static void main(String[] args) {
        try {
            int[] numbers = {1, 2, 3};
            System.out.println(numbers[4]); // 数组越界异常
            
            int result = divide(10, 0); // 除零异常
            System.out.println("结果：" + result);
        } catch (ArrayIndexOutOfBoundsException e) {
            System.out.println("捕获到数组越界异常！");
            e.printStackTrace();
        } catch (ArithmeticException e) {
            System.out.println("捕获到除零异常！");
            e.printStackTrace();
        } catch (Exception e) {
            System.out.println("捕获到其他异常！");
            e.printStackTrace();
        }

        System.out.println("异常处理完成！");
    }

    public static int divide(int dividend, int divisor) {
        return dividend / divisor;
    }
}

Resultados de la:

Podemos ver que la excepción de división por cero no se detectará en absoluto, porque después de que ocurra la primera excepción fuera de los límites de la matriz, se omitirá todo el resto de la declaración de prueba.

Métodos comunes en el manejo manual de excepciones:

Throwable Es la clase raíz de todas las clases de excepción en Java, que define algunos métodos comunes que se pueden usar en el manejo de excepciones. Throwable Estos son algunos métodos comúnmente utilizados :

getMessage(): Devuelve la descripción detallada de la excepción.

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    System.out.println(e.getMessage()); // 打印异常信息
}

printStackTrace(): envía la información de la pila de seguimiento de la excepción al flujo de error estándar ( System.err), que se puede usar para depurar y ubicar dónde ocurrió la excepción.

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    e.printStackTrace(); // 输出异常跟踪栈信息
}

getCause(): Devuelve la excepción de causa que provocó la excepción actual, generalmente utilizada en escenarios de excepciones anidadas.

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    Throwable cause = e.getCause();
    if (cause != null) {
        System.out.println("导致异常的原因：" + cause.getMessage());
    }
}

getLocalizedMessage(): devuelve la información de descripción de la localización de la excepción, si la clase de excepción proporciona una descripción de la localización, devuelve la información de la descripción de la localización, de lo contrario, devuelve la información de la descripción de la excepción.

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    System.out.println(e.getLocalizedMessage()); // 打印异常的本地化描述信息
}

toString(): Devuelve una representación de cadena de la excepción, incluido el nombre de la clase de excepción y una descripción detallada.

try {
    // 可能抛出异常的代码
} catch (Exception e) {
    System.out.println(e.toString()); // 打印异常的字符串表示
}

Estos son Throwable algunos métodos comunes de la clase. Debe tenerse en cuenta que Throwable existen otros métodos y algunos métodos específicos de subclases que se pueden comprender y utilizar más cuando sea necesario.

3. Procesamiento de lanzamiento

lanza:

throws Las palabras clave se utilizan en las declaraciones de métodos para especificar los tipos de excepciones que puede generar el método. Mediante el uso throws de palabras clave, las excepciones se pueden pasar a la persona que llama o al código de nivel superior para su manejo en lugar de ser capturadas y manejadas dentro del método.

Aquí hay un throws ejemplo simple de uso:

import java.io.FileNotFoundException;
import java.io.FileReader;

public class FileProcessor {
    public static void main(String[] args) {
        try {
            readFile("file.txt");
        } catch (FileNotFoundException e) {
            System.out.println("文件不存在！");
            e.printStackTrace();
        }
    }

    public static void readFile(String fileName) throws FileNotFoundException {
        FileReader fileReader = new FileReader(fileName);
        // 进行文件读取操作
        // ...
    }
}

En el código anterior, tenemos un readFile método para leer el contenido del archivo especificado. Dado que puede ocurrir una excepción al leer un archivo, la excepción throws que puede generarse se especifica mediante palabras clave en la declaración del método FileNotFoundException .

Cuando main se llama a un método readFile("file.txt") , se lanzará una excepción si el archivo no existe FileNotFoundException . Dado que solemos throws declarar las excepciones que pueden generarse, debemos capturar y manejar la excepción mediante el main uso de un bloque en el método .catch

Al usarlo throws, podemos transferir la responsabilidad del manejo de excepciones a la persona que llama o al código superior, lo que hace que el código sea más modular y flexible. La persona que llama puede elegir capturar y manejar la excepción, o continuar pasando la excepción al código superior hasta que haya un mecanismo de manejo de excepciones correspondiente.

tirar:

throw La palabra clave se utiliza para lanzar manualmente una excepción. Se puede usar en cualquier lugar, incluso en métodos, constructores, bloques de código y otros mecanismos de manejo de excepciones. Mediante el uso throw de palabras clave, se pueden indicar errores o condiciones anormales en el programa, y el control se puede transferir al código superior o al mecanismo de manejo de excepciones para su procesamiento.

La sintaxis general para lanzar una excepción es la siguiente:

throw throwableObject;

Entre ellos, throwableObject se encuentra el objeto de excepción que se lanzará, que puede ser una instancia de la clase de excepción integrada de Java (como RuntimeException, IOException etc.) o una clase de excepción personalizada.

Aquí hay un throw ejemplo usando una excepción de lanzamiento:

public class AgeValidation {
    public static void main(String[] args) {
        try {
            int age = -5;
            validateAge(age);
        } catch (IllegalArgumentException e) {
            System.out.println("年龄无效！");
            e.printStackTrace();
        }
    }

    public static void validateAge(int age) {
        if (age < 0) {
            throw new IllegalArgumentException("年龄不能为负数！");
        }
        System.out.println("年龄有效！");
    }
}

En el código anterior, tenemos un validateAge método que recibe una edad como parámetro y verifica la validez de la edad comprobando si la edad es negativa. Utilice throw la palabra clave para lanzar manualmente una IllegalArgumentException excepción con el mensaje de error "¡La edad no puede ser negativa!" si la edad es negativa.

Cuando se llama en main el método validateAge(-5) , se pasa un número negativo como la edad, lo que provoca que se produzca una excepción. Luego, catch capture y maneje la excepción en el bloque.

Al usarlo throw, podemos lanzar manualmente una excepción cuando sea necesario, para indicar un error o una situación anormal en el programa, y transferir el control de la excepción al código de la capa superior o al mecanismo de manejo de excepciones. Esto ayuda a mejorar la legibilidad y el mantenimiento del programa y permite un manejo de excepciones más preciso.

La diferencia entre throw y throws:

throw y throws son palabras clave utilizadas en el manejo de excepciones, tienen las siguientes diferencias:

Las funciones son diferentes:
- throw Se utiliza para lanzar excepciones de forma activa. Se puede usar en cualquier lugar para lanzar manualmente un objeto de excepción.
- throws Se utiliza en la declaración del método para especificar los tipos de excepción que puede generar el método. Se utiliza para declarar las excepciones que el método actual puede arrojar a la persona que llama o al código superior, de modo que la persona que llama pueda manejar la excepción correctamente.
Se utilizan diferentes lugares:
- throw Las palabras clave se pueden usar en cualquier lugar dentro de métodos, constructores, bloques de código u otros mecanismos de manejo de excepciones.
- throws Las palabras clave solo se pueden usar en la parte de declaración de un método o constructor, y se usan para especificar las excepciones que puede generar el método.
Las responsabilidades del manejo de excepciones son diferentes:
- Inmediatamente después de throw lanzar una excepción, el control se transfiere al mecanismo de manejo de excepciones apropiado en la pila de llamadas, como try-catch un bloque.
- Después de throws declarar una excepción, el método aún puede continuar ejecutándose y la responsabilidad de manejar la excepción se transfiere al código que llamó al método.

En resumen, throw se usa para lanzar excepciones manualmente, y throws se usa para especificar los tipos de excepciones que se pueden lanzar en la declaración del método. throw desencadena directamente una excepción y transfiere el control al mecanismo de manejo de excepciones, y después de que throws declara una excepción, el método seguirá ejecutándose y lanzando la excepción a la persona que llama para su procesamiento.

Excepción personalizada:

En Java, las excepciones definidas por el usuario se pueden implementar mediante la creación de clases de excepción personalizadas. Las clases de excepción personalizadas pueden proporcionar información de excepción más específica y más clara de acuerdo con requisitos comerciales específicos o situaciones de excepción, y permitir que los desarrolladores manejen las excepciones de manera personalizada .

Los pasos para crear una clase de excepción personalizada son los siguientes:

Cree una clase que herede Exception o una subclase de ella, y asígnele el nombre que desee que sea la clase de excepción.
En una clase de excepción personalizada, puede agregar constructores personalizados y otros métodos para inicializar objetos de excepción y proporcionar información de excepción adicional.
Puede elegir anular los métodos de la clase principal o agregar métodos personalizados para satisfacer necesidades específicas. Por ejemplo, se pueden agregar métodos para obtener información de excepción más detallada.

Aquí hay un ejemplo de una clase de excepción personalizada simple:

public class InvalidAgeException extends Exception {
    private int age;

    public InvalidAgeException(int age) {
        super("年龄不合法！");
        this.age = age;
    }

    public int getAge() {
        return age;
    }
}

En el código anterior, hemos creado una clase de excepción personalizada InvalidAgeExceptionque hereda de Exception class. La clase de excepción tiene un constructor con parámetros para inicializar el objeto de excepción y proporcionar información sobre la edad. También agregamos un getAge método para obtener información sobre la edad.

Al usar clases de excepción personalizadas, puede manejarlas en su código de la misma manera que maneja las clases de excepción integradas. Por ejemplo, los bloques se pueden usar try-catch para capturar y manejar excepciones personalizadas.

Aquí hay un ejemplo usando una excepción personalizada:

public class AgeValidation {
    public static void main(String[] args) {
        try {
            int age = -5;
            validateAge(age);
        } catch (InvalidAgeException e) {
            System.out.println("年龄无效！年龄为：" + e.getAge());
            e.printStackTrace();
        }
    }

    public static void validateAge(int age) throws InvalidAgeException {
        if (age < 0) {
            throw new InvalidAgeException(age);
        }
        System.out.println("年龄有效！");
    }
}

En el código anterior, usamos una clase de excepción personalizada InvalidAgeException para implementar la verificación de edad. Cuando la edad es negativa, usamos throw la palabra clave para generar InvalidAgeException una excepción y pasar la edad como parámetro al constructor de excepciones. En main el método, try-catch la excepción es capturada y manejada por el bloque.

El uso de clases de excepción personalizadas puede proporcionar información de excepción más específica y detallada, lo que hace que el manejo de excepciones sea más preciso y controlable. Permite a los desarrolladores crear y manejar excepciones de acuerdo con las necesidades comerciales específicas, mejorando así la legibilidad y la capacidad de mantenimiento del programa.

Ventajas de las excepciones:

1. Mecanismo de manejo de excepciones : las excepciones proporcionan un mecanismo de manejo de errores estructurado que permite a los desarrolladores detectar, capturar y manejar errores más fácilmente. Mediante el uso juicioso del manejo de excepciones, puede mejorar la facilidad de mantenimiento y la legibilidad de su código.

2. Separación del proceso normal y la lógica de manejo de excepciones : el mecanismo de excepción separa la lógica comercial normal de la lógica de manejo de excepciones. De esta forma, al escribir código, puede concentrarse en el flujo lógico de los casos normales y tratar las excepciones como casos especiales.

3. Proporcione información de error y seguimiento de la pila : el objeto de excepción contiene información detallada sobre el error, como el tipo de excepción, el mensaje de error y el seguimiento de la pila. Esta información puede ayudar a los desarrolladores a localizar y resolver problemas rápidamente y acortar el tiempo de depuración.

4. Propagación y procesamiento de excepciones : el mecanismo de excepciones permite que las excepciones se propaguen en la pila de llamadas hasta que se capturen y procesen. Esto significa que las excepciones en un método pueden ser detectadas y manejadas por la persona que llama al método, lo que permite que el manejo de excepciones se lleve a cabo en diferentes niveles.

5. Mejore la confiabilidad y la estabilidad del código : al detectar y manejar las excepciones, puede evitar que los programas se bloqueen o se comporten de manera impredecible debido a errores. El manejo razonable de las excepciones puede mejorar la solidez del código y hacer que el programa sea más confiable y estable.

6. Liberación de recursos : el mecanismo de manejo de excepciones también puede garantizar que los recursos del sistema se liberen y cierren correctamente en circunstancias anormales, evitando fugas de recursos y otros problemas.

Resumir:

En este artículo, hemos presentado los puntos de conocimiento sobre las excepciones en detalle. El uso de excepciones puede mejorar nuestra capacidad de controlar el código. Las excepciones son como un bisturí, que puede cortar con precisión nuestras partes de errores y permitirnos verificar rápidamente el código. Modificar, excepción es una poderosa herramienta de manejo de errores que puede ayudar a los desarrolladores a manejar las excepciones con gracia y mejorar la confiabilidad y el mantenimiento del código. El uso razonable del mecanismo de manejo de excepciones puede mejorar la calidad del programa y mejorar la eficiencia del desarrollo.

Si mi contenido es útil para ti, dale me gusta, comenta y marca . ¡La creación no es fácil, el apoyo de todos es mi motivación para perseverar!

[Aprende JAVA desde cero | Artículo 32] Anomalías (Parte 2) ¡Los novatos deben aprender!

Prefacio:

Excepciones:

Las dos funciones de las excepciones son:

Manejo de excepciones:

1. Procesamiento predeterminado de JVM

2. Atrapa la excepción tú mismo

3. Procesamiento de lanzamiento

Excepción personalizada:

Ventajas de las excepciones:

Resumir:

Supongo que te gusta